diff --git a/org.eclipse.jdt.apt.core/META-INF/MANIFEST.MF b/org.eclipse.jdt.apt.core/META-INF/MANIFEST.MF
index 8055230..29f3702 100644
--- a/org.eclipse.jdt.apt.core/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.apt.core/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.apt.core; singleton:=true
-Bundle-Version: 3.2.0.qualifier
+Bundle-Version: 3.2.1.qualifier
 Bundle-Localization: plugin
 Export-Package: com.sun.mirror.apt,
  com.sun.mirror.declaration,
diff --git a/org.eclipse.jdt.apt.core/schema/annotationProcessorFactory.exsd b/org.eclipse.jdt.apt.core/schema/annotationProcessorFactory.exsd
index 2b26473..d2bca17 100644
--- a/org.eclipse.jdt.apt.core/schema/annotationProcessorFactory.exsd
+++ b/org.eclipse.jdt.apt.core/schema/annotationProcessorFactory.exsd
@@ -6,7 +6,7 @@
          <meta.schema plugin="org.eclipse.jdt.apt.core" id="annotationProcessorFactory" name="Annotation Processor Factories"/>
       </appInfo>
       <documentation>
-         [Enter description of this extension point.]
+         Plug-ins which contribute JSR-175 annotation processors should extend this extension point in order to participate in compilation.
       </documentation>
    </annotation>
 
@@ -61,18 +61,24 @@
 
    <element name="factory">
       <complexType>
-         <attribute name="class" type="string">
+         <attribute name="class" type="string" use="required">
             <annotation>
                <documentation>
-                  
+                  Qualified name of a class that implements com.sun.mirror.apt.AnnotationProcessorFactory and has a no-argument constructor.
                </documentation>
+               <appInfo>
+                  <meta.attribute kind="java" basedOn="com.sun.mirror.apt.AnnotationProcessorFactory"/>
+               </appInfo>
             </annotation>
          </attribute>
          <attribute name="implements" type="string">
             <annotation>
                <documentation>
-                  
+                  Reserved.  Do not use this attribute.
                </documentation>
+               <appInfo>
+                  <meta.attribute deprecated="true"/>
+               </appInfo>
             </annotation>
          </attribute>
       </complexType>
@@ -92,7 +98,19 @@
          <meta.section type="examples"/>
       </appInfo>
       <documentation>
-         [Enter extension point usage example here.]
+         Example of a declaration of an &lt;code&gt;annotationProcessorFactory&lt;/code&gt;:  &lt;pre&gt;                                                                       
+     &lt;extension
+         point=&quot;org.eclipse.jdt.apt.core.annotationProcessorFactory&quot;&gt;
+      &lt;factories enableDefault=&quot;true&quot;&gt;
+       &lt;factory
+          class=&quot;org.xyz.HelloWorldAnnotationProcessorFactory&quot;&gt;
+       &lt;/factory&gt;
+       &lt;factory
+          class=&quot;org.xyz.GoodNightMoonAnnotationProcessorFactory&quot;&gt;
+       &lt;/factory&gt;
+    &lt;/factories&gt;
+   &lt;/extension&gt;
+&lt;/pre&gt;
       </documentation>
    </annotation>
 
@@ -119,7 +137,11 @@
          <meta.section type="copyright"/>
       </appInfo>
       <documentation>
-         
+         Copyright (c) 2005 BEA Systems, Inc and others.&lt;br&gt;
+All rights reserved. This program and the accompanying materials
+are made available under the terms of the Eclipse Public License v1.0
+which accompanies this distribution, and is available at 
+&lt;a href=&quot;http://www.eclipse.org/legal/epl-v10.html&quot;&gt;http://www.eclipse.org/legal/epl-v10.html&lt;/a&gt;
       </documentation>
    </annotation>
 
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/build/JdtApt.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/build/JdtApt.java
index ef194ea..208fcdd 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/build/JdtApt.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/build/JdtApt.java
@@ -23,14 +23,14 @@
  *
  * Sample build.xml:
  * 
- * <project name="test_eclipse" default="build" basedir=".">
+ * &lt;project name="test_eclipse" default="build" basedir="."&gt;
  * 
- *    <taskdef name="apt" classname="org.eclipse.jdt.apt.core.build.JdtApt"/>
+ *    &lt;taskdef name="apt" classname="org.eclipse.jdt.apt.core.build.JdtApt"/&gt;
  *
- *    <target name="build">
- *        <apt workspace="C:\my_workspace" eclipseHome="C:\eclipse"/>
- *    </target>
- * </project>
+ *    &lt;target name="build"&gt;
+ *        &lt;apt workspace="C:\my_workspace" eclipseHome="C:\eclipse"/&gt;
+ *    &lt;/target&gt;
+ * &lt;/project&gt;
  */
 public class JdtApt extends Java {
 
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AbstractCompilationEnv.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AbstractCompilationEnv.java
index 5db7e8c..0dcc4b4 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AbstractCompilationEnv.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/AbstractCompilationEnv.java
@@ -17,14 +17,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.regex.Pattern;
 
 import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.resources.ResourcesPlugin;
-import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
 import org.eclipse.jdt.apt.core.env.EclipseAnnotationProcessorEnvironment;
 import org.eclipse.jdt.apt.core.env.Phase;
 import org.eclipse.jdt.apt.core.internal.declaration.EclipseMirrorObject;
@@ -32,13 +26,11 @@
 import org.eclipse.jdt.apt.core.internal.env.MessagerImpl.Severity;
 import org.eclipse.jdt.apt.core.internal.util.Factory;
 import org.eclipse.jdt.apt.core.internal.util.Visitors.AnnotationVisitor;
-import org.eclipse.jdt.apt.core.util.AptConfig;
 import org.eclipse.jdt.apt.core.util.EclipseMessager;
 import org.eclipse.jdt.core.BindingKey;
 import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.core.compiler.CategorizedProblem;
 import org.eclipse.jdt.core.compiler.BuildContext;
+import org.eclipse.jdt.core.compiler.CategorizedProblem;
 import org.eclipse.jdt.core.compiler.ReconcileContext;
 import org.eclipse.jdt.core.dom.ASTRequestor;
 import org.eclipse.jdt.core.dom.Annotation;
@@ -54,21 +46,9 @@
 	extends BaseProcessorEnv 
 	implements EclipseAnnotationProcessorEnvironment{
 	
-	/** regex to identify substituted token in path variables */
-	private static final String PATHVAR_TOKEN = "^%[^%/\\\\ ]+%.*"; //$NON-NLS-1$
-	/** path variable meaning "workspace root" */
-	private static final String PATHVAR_ROOT = "%ROOT%"; //$NON-NLS-1$
-	/** path variable meaning "project root" */
-	private static final String PATHVAR_PROJECTROOT = "%PROJECT.DIR%"; //$NON-NLS-1$
-
 	private Set<AnnotationProcessorListener> _listeners = null;
 	
 	protected List<APTProblem> _problems = new ArrayList<APTProblem>();
-	/**
-	 * Processor options, including -A options.
-	 * Set in ctor and then not changed.
-	 */
-	private Map<String, String> _options;
 	private boolean _isClosed = false;
 	
 	EnvCallback _callback;
@@ -111,7 +91,6 @@
 			Phase phase)
 	{
 		super(compilationUnit, file, javaProj, phase);
-		initOptions(javaProj);
 	}
 	
 	@Override
@@ -143,94 +122,6 @@
 		return Collections.unmodifiableSet(_listeners);
 	}
 	
-	/**
-     * Set the _options map based on the current project/workspace settings.
-     * There is a bug in Sun's apt implementation: it parses the command line 
-     * incorrectly, such that -Akey=value gets added to the options map as 
-     * key "-Akey=value" and value "".  In order to support processors written 
-     * to run on Sun's apt as well as processors written without this bug
-     * in mind, we populate the map with two copies of every option, one the
-     * expected way ("key" / "value") and the other the Sun way 
-     * ("-Akey=value" / "").  We make exceptions for the non-dash-A options
-     * that we set automatically, such as -classpath, -target, and so forth;
-     * since these wouldn't have come from a -A option we don't construct a
-     * -Akey=value variant.
-     * 
-     * Called from constructor.  A new Env is constructed for each build pass,
-     * so this will always be up to date with the latest settings.
-	 */
-	private void initOptions(IJavaProject jproj) {
-		Map<String, String> procOptions = AptConfig.getProcessorOptions(jproj);
-		_options = new HashMap<String, String>(procOptions.size() * 2);
-		
-		// Add configured options
-		for (Map.Entry<String, String> entry : procOptions.entrySet()) {
-			String value = resolveVarPath(jproj, entry.getValue());
-			String key = entry.getKey();
-			_options.put(key, value);
-			if (!AptConfig.isAutomaticProcessorOption(key)) {
-				String sunStyle;
-				if (value != null) {
-					sunStyle = "-A" + entry.getKey() + "=" + value; //$NON-NLS-1$ //$NON-NLS-2$
-				}
-				else {
-					sunStyle = "-A" + entry.getKey(); //$NON-NLS-1$
-				}
-				_options.put(sunStyle, ""); //$NON-NLS-1$
-			}
-		}
-	}
-
-	/**
-	 * If the value starts with a path variable such as %ROOT%, replace it with
-	 * the absolute path.
-	 * @param value the value of a -Akey=value command option
-	 */
-	private String resolveVarPath(IJavaProject jproj, String value) {
-		if (value == null) {
-			return null;
-		}
-		// is there a token to substitute?
-		if (!Pattern.matches(PATHVAR_TOKEN, value)) {
-			return value;
-		}
-		IPath path = new Path(value);
-		String firstToken = path.segment(0);
-		// If it matches %ROOT%/project, it is a project-relative path.
-		if (PATHVAR_ROOT.equals(firstToken)) {
-			IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-			IResource proj = root.findMember(path.segment(1));
-			if (proj == null) {
-				return value;
-			}
-			// all is well; do the substitution
-			IPath relativePath = path.removeFirstSegments(2);
-			IPath absoluteProjPath = proj.getLocation();
-			IPath absoluteResPath = absoluteProjPath.append(relativePath);
-			return absoluteResPath.toOSString();
-		}
-		
-		// If it matches %PROJECT.DIR%/project, the path is relative to the current project.
-		if (jproj != null && PATHVAR_PROJECTROOT.equals(firstToken)) {
-			// all is well; do the substitution
-			IPath relativePath = path.removeFirstSegments(1);
-			IPath absoluteProjPath = jproj.getProject().getLocation();
-			IPath absoluteResPath = absoluteProjPath.append(relativePath);
-			return absoluteResPath.toOSString();
-		}
-		
-		// otherwise it's a classpath-var-based path.
-		String cpvName = firstToken.substring(1, firstToken.length() - 1);
-		IPath cpvPath = JavaCore.getClasspathVariable(cpvName);
-		if (cpvPath != null) {
-			IPath resolved = cpvPath.append(path.removeFirstSegments(1));
-			return resolved.toOSString();
-		}
-		else {
-			return value;
-		}
-	}
-	
 	public Map<String, String> getOptions()
     {
         final HashMap<String, String> options = new HashMap<String, String>(_options);
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/BaseProcessorEnv.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/BaseProcessorEnv.java
index 3764c4f..d458f63 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/BaseProcessorEnv.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/env/BaseProcessorEnv.java
@@ -31,6 +31,7 @@
 import org.eclipse.jdt.apt.core.internal.util.PackageUtil;
 import org.eclipse.jdt.apt.core.internal.util.TypesUtil;
 import org.eclipse.jdt.apt.core.internal.util.Visitors.AnnotatedNodeVisitor;
+import org.eclipse.jdt.apt.core.util.AptConfig;
 import org.eclipse.jdt.core.BindingKey;
 import org.eclipse.jdt.core.IClassFile;
 import org.eclipse.jdt.core.ICompilationUnit;
@@ -101,6 +102,12 @@
 	protected final AptProject _aptProject;
 	
 	/**
+	 * Unmodifiable map of processor options, including -A options.
+	 * Set in ctor and then not changed.
+	 */
+	protected final Map<String, String> _options;
+
+	/**
      * Mapping model compilation unit to dom compilation unit.
      * The assumption here is that once the client examine some binding from some file, 
      * it will continue to examine other bindings from came from that same file.
@@ -131,12 +138,52 @@
 		_file = file;
 		_javaProject = javaProj;
 		_phase = phase;
-		
+		_options = initOptions(javaProj);
 		_modelCompUnit2astCompUnit = new HashMap<ICompilationUnit, CompilationUnit>();
 		_typeBinding2ModelCompUnit = new HashMap<ITypeBinding, ICompilationUnit>();
 		_aptProject = AptPlugin.getAptProject(javaProj);
 	}
   
+	/**
+     * Set the _options map based on the current project/workspace settings.
+     * There is a bug in Sun's apt implementation: it parses the command line 
+     * incorrectly, such that -Akey=value gets added to the options map as 
+     * key "-Akey=value" and value "".  In order to support processors written 
+     * to run on Sun's apt as well as processors written without this bug
+     * in mind, we populate the map with two copies of every option, one the
+     * expected way ("key" / "value") and the other the Sun way 
+     * ("-Akey=value" / "").  We make exceptions for the non-dash-A options
+     * that we set automatically, such as -classpath, -target, and so forth;
+     * since these wouldn't have come from a -A option we don't construct a
+     * -Akey=value variant.
+     * 
+     * Called from constructor.  A new Env is constructed for each build pass,
+     * so this will always be up to date with the latest settings.
+	 */
+	private Map<String, String> initOptions(IJavaProject jproj) {
+		Map<String, String> procOptions = AptConfig.getProcessorOptions(jproj);
+		// options is large enough to include the translated -A options
+		Map<String, String> options = new HashMap<String, String>(procOptions.size() * 2);
+		
+		// Add configured options
+		for (Map.Entry<String, String> entry : procOptions.entrySet()) {
+			String value = entry.getValue();
+			String key = entry.getKey();
+			options.put(key, value);
+			if (!AptConfig.isAutomaticProcessorOption(key)) {
+				String sunStyle;
+				if (value != null) {
+					sunStyle = "-A" + entry.getKey() + "=" + value; //$NON-NLS-1$ //$NON-NLS-2$
+				}
+				else {
+					sunStyle = "-A" + entry.getKey(); //$NON-NLS-1$
+				}
+				options.put(sunStyle, ""); //$NON-NLS-1$
+			}
+		}
+		return Collections.unmodifiableMap(options);
+	}
+
 	public Types getTypeUtils()
     {
 		return new TypesUtil(this);
@@ -341,7 +388,7 @@
 		return astUnit.findDeclaringNode(binding.getKey());
     }
     
-    public Map<String, String> getOptions(){ return Collections.emptyMap(); }
+    public Map<String, String> getOptions(){ return _options; }
     
     // does not generate dependencies
     public TypeDeclaration getTypeDeclaration(String name)
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/FactoryPathUtil.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/FactoryPathUtil.java
index 78f1d71..ad49ba3 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/FactoryPathUtil.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/internal/util/FactoryPathUtil.java
@@ -579,7 +579,7 @@
 							pfc.addFactoryName(factoryName);
 						}
 					} catch(CoreException e) {
-							e.printStackTrace();
+						AptPlugin.log(e, "Unable to load annotation factory from plug-in"); //$NON-NLS-1$
 					}
 				}
 			}
diff --git a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/util/AptConfig.java b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/util/AptConfig.java
index ca8fe4a..c2a911e 100644
--- a/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/util/AptConfig.java
+++ b/org.eclipse.jdt.apt.core/src/org/eclipse/jdt/apt/core/util/AptConfig.java
@@ -19,15 +19,18 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.Map.Entry;
+import java.util.regex.Pattern;
 
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ProjectScope;
+import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.preferences.DefaultScope;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
@@ -58,6 +61,13 @@
  */
 public class AptConfig {
 	
+	/** regex to identify substituted token in path variables */
+	private static final String PATHVAR_TOKEN = "^%[^%/\\\\ ]+%.*"; //$NON-NLS-1$
+	/** path variable meaning "workspace root" */
+	private static final String PATHVAR_ROOT = "%ROOT%"; //$NON-NLS-1$
+	/** path variable meaning "project root" */
+	private static final String PATHVAR_PROJECTROOT = "%PROJECT.DIR%"; //$NON-NLS-1$
+
 	/*
 	 * Hide constructor; this is a static object
 	 */
@@ -112,8 +122,18 @@
     
 	/**
      * Get the options that are presented to annotation processors by the
-     * AnnotationProcessorEnvironment.  The -A and = are stripped out, so 
-     * (key, value) is the equivalent of -Akey=value.
+     * AnnotationProcessorEnvironment.  Options are key/value pairs which
+     * are set in the project properties.
+     * 
+     * Option values can begin with a percent-delimited token representing
+     * a classpath variable or one of several predefined values.  The token
+     * must either be followed by a path delimiter, or be the entire value.
+     * Such tokens will be replaced with their resolved value.  The predefined
+     * values are <code>%ROOT%</code>, which is replaced by the absolute pathname
+     * of the workspace root directory, and <code>%PROJECT.DIR%</code>, which
+     * will be replaced by the absolute pathname of the project root directory.
+     * For example, a value of <code>%ECLIPSE_HOME%/configuration/config.ini</code>
+     * might be resolved to <code>d:/eclipse/configuration/config.ini</code>. 
      * 
      * This method returns some options which are set programmatically but 
      * are not directly editable, are not displayed in the configuration GUI, 
@@ -121,21 +141,42 @@
      * emulate the behavior of Sun's apt command-line tool, which passes
      * most of its command line options to the processor environment.  The
      * programmatically set options are:
-     *  -classpath [set to Java build path]
-     *  -sourcepath [set to Java source path]
-     *  -s [set to generated src dir]
-     *  -d [set to binary output dir]
-     *  -target [set to compiler target version]
-     *  -source [set to compiler source version]
+     *  <code>-classpath</code> [set to Java build path]
+     *  <code>-sourcepath</code> [set to Java source path]
+     *  <code>-s</code> [set to generated src dir]
+     *  <code>-d</code> [set to binary output dir]
+     *  <code>-target</code> [set to compiler target version]
+     *  <code>-source</code> [set to compiler source version]
+     *  
+     * There are some slight differences between the options returned by this
+     * method and the options returned from this implementation of @see 
+     * AnnotationProcessorEnvironment#getOptions().  First, that method returns 
+     * additional options which are only meaningful during a build, such as 
+     * <code>phase</code>.  Second, that method also adds alternate encodings
+     * of each option, to be compatible with a bug in Sun's apt implementation:
+     * specifically, for each option key="k", value="v", an additional option
+     * is created with key="-Ak=v", value=null.  This includes the user-created
+     * options, but does not include the programmatically defined options listed
+     * above.
      * 
      * @param jproj a project, or null to query the workspace-wide setting.
      * @return a mutable, possibly empty, map of (key, value) pairs.  
-     * The value part of a pair may be null (equivalent to "-Akey").
-     * The value part can contain spaces, if it is quoted: -Afoo="bar baz".
+     * The value part of a pair may be null (equivalent to "-Akey" on the Sun apt
+     * command line).
+     * The value part may contain spaces.
      */
     public static Map<String, String> getProcessorOptions(IJavaProject jproj) {
-    	Map<String,String> options;
-    	options = getRawProcessorOptions(jproj);
+    	Map<String,String> rawOptions = getRawProcessorOptions(jproj);
+    	// map is large enough to also include the programmatically generated options
+    	Map<String, String> options = new HashMap<String, String>(rawOptions.size() + 6);
+    	
+    	// Resolve path metavariables like %ROOT%
+    	for (Map.Entry<String, String> entry : rawOptions.entrySet()) {
+    		String resolvedValue = resolveVarPath(jproj, entry.getValue());
+    		String value = (resolvedValue == null) ? entry.getValue() : resolvedValue;
+    		options.put(entry.getKey(), value);
+    	}
+    	
     	if (jproj == null) {
     		// there are no programmatically set options at the workspace level
     		return options;
@@ -233,7 +274,57 @@
     	return options;
     }
     
-    // We need this as a separate method, as we'll put dependent projects' output
+	/**
+	 * If the value starts with a path variable such as %ROOT%, replace it with
+	 * the absolute path.
+	 * @param value the value of a -Akey=value command option
+	 */
+	private static String resolveVarPath(IJavaProject jproj, String value) {
+		if (value == null) {
+			return null;
+		}
+		// is there a token to substitute?
+		if (!Pattern.matches(PATHVAR_TOKEN, value)) {
+			return value;
+		}
+		IPath path = new Path(value);
+		String firstToken = path.segment(0);
+		// If it matches %ROOT%/project, it is a project-relative path.
+		if (PATHVAR_ROOT.equals(firstToken)) {
+			IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+			IResource proj = root.findMember(path.segment(1));
+			if (proj == null) {
+				return value;
+			}
+			// all is well; do the substitution
+			IPath relativePath = path.removeFirstSegments(2);
+			IPath absoluteProjPath = proj.getLocation();
+			IPath absoluteResPath = absoluteProjPath.append(relativePath);
+			return absoluteResPath.toOSString();
+		}
+		
+		// If it matches %PROJECT.DIR%/project, the path is relative to the current project.
+		if (jproj != null && PATHVAR_PROJECTROOT.equals(firstToken)) {
+			// all is well; do the substitution
+			IPath relativePath = path.removeFirstSegments(1);
+			IPath absoluteProjPath = jproj.getProject().getLocation();
+			IPath absoluteResPath = absoluteProjPath.append(relativePath);
+			return absoluteResPath.toOSString();
+		}
+		
+		// otherwise it's a classpath-var-based path.
+		String cpvName = firstToken.substring(1, firstToken.length() - 1);
+		IPath cpvPath = JavaCore.getClasspathVariable(cpvName);
+		if (cpvPath != null) {
+			IPath resolved = cpvPath.append(path.removeFirstSegments(1));
+			return resolved.toOSString();
+		}
+		else {
+			return value;
+		}
+	}
+	
+	// We need this as a separate method, as we'll put dependent projects' output
     // on the classpath
     private static void addProjectClasspath(
     		IWorkspaceRoot root,
diff --git a/org.eclipse.jdt.apt.tests/META-INF/MANIFEST.MF b/org.eclipse.jdt.apt.tests/META-INF/MANIFEST.MF
index 4ded349..c57e8e9 100644
--- a/org.eclipse.jdt.apt.tests/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.apt.tests/META-INF/MANIFEST.MF
@@ -2,7 +2,7 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.apt.tests; singleton:=true
-Bundle-Version: 3.2.0.qualifier
+Bundle-Version: 3.2.1.qualifier
 Bundle-ClassPath: apt.jar,
  aptext.jar
 Bundle-Activator: org.eclipse.jdt.apt.tests.plugin.AptTestsPlugin
@@ -11,8 +11,10 @@
  org.eclipse.jdt.apt.tests.annotations,
  org.eclipse.jdt.apt.tests.annotations.apitest,
  org.eclipse.jdt.apt.tests.annotations.aptrounding,
+ org.eclipse.jdt.apt.tests.annotations.exceptionhandling,
  org.eclipse.jdt.apt.tests.annotations.extradependency,
  org.eclipse.jdt.apt.tests.annotations.filegen,
+ org.eclipse.jdt.apt.tests.annotations.generic,
  org.eclipse.jdt.apt.tests.annotations.helloworld,
  org.eclipse.jdt.apt.tests.annotations.messager,
  org.eclipse.jdt.apt.tests.annotations.mirrortest,
@@ -28,12 +30,10 @@
  org.eclipse.jdt.apt.tests.plugin
 Require-Bundle: org.junit,
  org.eclipse.jdt.apt.core,
- org.eclipse.jdt.apt.ui,
  org.eclipse.jdt.core,
  org.eclipse.jdt.core.tests.builder,
  org.eclipse.jdt.core.tests.compiler,
  org.eclipse.jdt.core.tests.model,
- org.eclipse.jdt.core.tests.performance,
  org.eclipse.core.resources,
  org.eclipse.core.runtime,
  org.eclipse.test.performance
diff --git a/org.eclipse.jdt.apt.ui/META-INF/MANIFEST.MF b/org.eclipse.jdt.apt.ui/META-INF/MANIFEST.MF
index e2a8a54..64cc4f1 100644
--- a/org.eclipse.jdt.apt.ui/META-INF/MANIFEST.MF
+++ b/org.eclipse.jdt.apt.ui/META-INF/MANIFEST.MF
@@ -2,17 +2,19 @@
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jdt.apt.ui; singleton:=true
-Bundle-Version: 3.2.0.qualifier
+Bundle-Version: 3.2.1.qualifier
 Bundle-Activator: org.eclipse.jdt.apt.ui.internal.AptUIPlugin
 Bundle-Localization: plugin
-Require-Bundle:  org.eclipse.jdt.apt.core;bundle-version="[3.2.0,4.0.0)",
+Require-Bundle: org.eclipse.jdt.apt.core;bundle-version="[3.2.0,4.0.0)",
  org.eclipse.jdt.ui;bundle-version="[3.2.0,4.0.0)",
  org.eclipse.jdt.core;bundle-version="[3.2.0,4.0.0)",
  org.eclipse.ui;bundle-version="[3.2.0,4.0.0)",
  org.eclipse.core.runtime;bundle-version="[3.2.0,4.0.0)",
  org.eclipse.core.resources;bundle-version="[3.2.0,4.0.0)",
- org.eclipse.help;bundle-version="[3.2.0,4.0.0)",
  org.eclipse.ui.forms;bundle-version="[3.2.0,4.0.0)"
 Eclipse-LazyStart: true
 Bundle-Vendor: Eclipse.org
 Bundle-RequiredExecutionEnvironment: J2SE-1.5
+Export-Package: org.eclipse.jdt.apt.ui.internal;x-internal:=true,
+ org.eclipse.jdt.apt.ui.internal.preferences;x-internal:=true,
+ org.eclipse.jdt.apt.ui.internal.util;x-internal:=true