initial version

19 files changed, 5883 insertions, 0 deletions

diff --git a/build/src/$installer$/org/aspectj/Main.java b/build/src/$installer$/org/aspectj/Main.java
new file mode 100644
index 000000000..b7cdda94e
--- /dev/null
+++ b/build/src/$installer$/org/aspectj/Main.java
@@ -0,0 +1,1699 @@
+/* *******************************************************************
+ * Copyright (c) 2000-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+
+
+package $installer$.org.aspectj;
+
+import javax.swing.*;
+import javax.swing.border.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.net.URL;
+import java.util.zip.*;
+import java.util.*;
+import java.lang.reflect.InvocationTargetException;
+
+/**
+ * Invoke the Installer gui.
+ * To run without gui, pass two arguments:
+ * <li> "-text".equals(arg[0])</li>
+ * <li> arg[1] is the path to a properties file which defines
+ *   name="output.dir" value="{path to output dir}"
+ *   name="context.javaPath" value="{path to JDKDIR}", i.e,.
+ *   <pre>output.dir=c:/latest
+ *   "context.javaPath=c:/apps/jdk1.3.1</pre></li>
+ * <li>outputDir must be created and empty (i.e., no overwriting</li>
+ * <li>the VM being invoked should be the target vm</li>
+ */
+public class Main {
+    public static void main(String[] args) {
+        Options.loadArgs(args);
+        boolean hasGui = (null == Options.textProperties);
+        Properties properties = new Properties();
+        InputStream istream = null;
+        try {
+            istream = Main.class.getResourceAsStream(Installer.RESOURCE_DIR + "/properties.txt");
+            if (istream == null) {
+                System.err.println("unable to load properties.txt using Main.class - exiting");
+                Main.exit(-1);
+            }
+            properties.load(istream);
+            if (!hasGui) {
+                istream.close();
+                istream = new FileInputStream(Options.textProperties);
+                properties.load(istream);
+            }
+            istream.close();
+            istream = null;
+        } catch (IOException ioe) {
+            handleException(ioe);
+        } finally {
+            if (null != istream) {
+                try {istream.close();}
+                catch (IOException e){} // ignore
+            }
+        }
+
+        try {
+            String className = (String)properties.get("installer.main.class");
+            //UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+            Installer installer = (Installer)Class.forName(className).newInstance();
+            InstallContext installerContext = new InstallContext(properties);
+            installerContext.setHasGui(hasGui);
+            installer.setContext(installerContext);
+            if (installerContext.hasGui()) { // let context force whether or not to run gui
+                installer.runGUI();
+            } else {
+                // set output dir and java path in context after minimal validation
+                String propName = "output.dir";
+                String propValue = properties.getProperty(propName);
+                if (null == propValue) {
+                    throw new Exception("expecting property " + propName);
+                }
+                String outputDirName = propValue;
+                propName = "context.javaPath";
+                propValue = properties.getProperty(propName);
+                if (null == propValue) {
+                    throw new Exception("expecting property " + propName);
+                }
+                String javaPath = propValue;
+                File outputDir = new File(outputDirName);
+                if (! outputDir.isDirectory()) {
+                    throw new Exception("not a dir outputDirName: " + outputDirName
+                                        + " dir: " + outputDir);
+                }
+                if (! outputDir.canWrite()) {
+                    throw new Exception("cannot write outputDirName: " + outputDirName
+                                        + " dir: " + outputDir);
+                }
+                InstallContext context = installer.getContext(); // todo: why not use installerContext?
+                context.setOutputDir(outputDir);
+                context.javaPath = new File(javaPath);
+                // todo: check javaPath for ... bin/java? lib/rt.jar?
+                if (! outputDir.isDirectory() || ! outputDir.canRead()) {
+                    throw new Exception("invalid javaPath: " + javaPath);
+                }
+                // directly set context and run
+                installer.getInstallPane().setContext(installerContext);
+                installer.run();
+            }
+        } catch (Exception e) {
+            handleException(e);
+        }
+    }
+
+    public static void handleException(Throwable e) {
+        System.out.println("internal error: " + e.toString());
+        e.printStackTrace();
+        Main.exit(-1);
+    }
+
+    /** indirection for System.exit - todo apply cleanup here as necessary */
+    public static void exit(int value) {
+        System.exit(value);
+    }
+} // class Main
+
+class Options {
+    public static boolean verbose = false;
+    public static String textProperties = null;
+    public static boolean forceError1 = false;
+    public static boolean forceError2 = false;
+    public static boolean forceHandConfigure = false;
+
+    public static void loadArgs(String[] args) {
+        if (args == null) return;
+        for (int i=0; i<args.length; i++) {
+            String arg = args[i];
+            if (arg == null) continue;
+
+            if (arg.equals("-verbose")) verbose = true;
+            else if (arg.equals("-forceError1")) forceError1 = true;
+            else if (arg.equals("-forceError2")) forceError2 = true;
+            else if (arg.equals("-forceHandConfigure")) forceHandConfigure = true;
+            else if (arg.equals("-text")) {
+                if (i+1 < args.length) {
+                    textProperties = args[++i];
+                }
+            }
+        }
+    }
+}
+
+class ToolsInstaller extends Installer {
+    public String getTitle() { return "AspectJ(TM) Compiler and Core Tools Installer"; }
+
+    public String getPrefix() { return "tools"; }
+
+    public ToolsInstaller() {
+        InstallPane installPane = new InstallPane(true);
+        setInstallPane(installPane);
+        panes = new WizardPane[] {
+          new IntroPane(),
+          new ConfigureLauncherPane(),
+          new LocationPane(),
+          installPane,
+          new FinishPane()
+        };
+    }
+}
+
+class DocsInstaller extends Installer {
+    public String getTitle() { return "AspectJ(TM) Documentation and Examples Installer"; }
+
+    public String getPrefix() { return "docs"; }
+
+    public DocsInstaller() {
+        InstallPane installPane = new InstallPane(false);
+        setInstallPane(installPane);
+        panes = new WizardPane[] {
+          new IntroPane(),
+          new LocationPane(),
+          installPane,
+          new FinishPane()
+        };
+    }
+}
+
+class AJDEForJBuilderInstaller extends Installer {
+    public String getTitle() { return "AspectJ(TM) Support for JBuilder"; }
+
+    public String getPrefix() { return "ajdeForJBuilder"; }
+
+    public AJDEForJBuilderInstaller() {
+        InstallPane installPane = new InstallPane(false);
+        setInstallPane(installPane);
+        panes = new WizardPane[] {
+          new IntroPane(),
+          new LocationPane() {
+              public String getDefaultLocation() {
+                if (context.onWindows()) {
+                    // check some default locations
+                    String[] paths = { "c:\\JBuilder6\\lib\\ext",
+                        "c:\\apps\\JBuilder6\\lib\\ext",
+                        "c:\\Program Files\\JBuilder6\\lib\\ext" };
+                    int pathIndex = 0;
+                    for (; pathIndex < paths.length; pathIndex++) {
+                        if (new File(paths[pathIndex]).exists()) return paths[pathIndex];
+                    }
+                    return "c:\\JBuilder6\\lib\\ext";
+                } else {
+                    return "/usr/JBuilder6/lib/ext";
+                }
+              }
+
+              /**
+               * Make sure that the old jar file gets removed.
+               */
+              public void verify() {
+                File jbuilder = new File(location.getText() + "/../../lib/jbuilder.jar");
+                if (!jbuilder.exists() && hasGui()) {
+                    int ret = JOptionPane.showConfirmDialog
+                        (frame,
+                         "The location you specified does not seem to be a " +
+                         "valid JBuilder install directory." +
+                         " Continue?", "Confirm Install",
+                         JOptionPane.YES_NO_OPTION,
+                         JOptionPane.QUESTION_MESSAGE);
+                    if (ret != JOptionPane.YES_OPTION) {
+                        Main.exit(-1);
+                    } else {
+                        // do nothing
+                    }
+                }
+
+                File oldFile = new File(location.getText() + "/ajbuilder.jar");
+                if (oldFile.exists() && hasGui()) {
+                    int ret = JOptionPane.showConfirmDialog(frame,
+                                                            "This old version of AJDE for JBuilder (\"ajbuilder.jar\") exists" +
+                                                            " and must be removed from the install directory." +
+                                                            " OK to delete?", "Confirm Delete",
+                                                            JOptionPane.YES_NO_OPTION,
+                                                            JOptionPane.QUESTION_MESSAGE);
+                    if (ret != JOptionPane.YES_OPTION) {
+                        Main.exit(-1);
+                    } else {
+                        oldFile.delete();
+                    }
+                }
+              }
+          },
+          installPane,
+          new FinishPane()
+        };
+    }
+}
+
+class AJDEForForteInstaller extends Installer {
+    public String getTitle() { return "AspectJ(TM) Support for Forte 4J"; }
+
+    public String getPrefix() { return "ajdeForForte"; }
+
+    private String installLoc = "";
+
+    public AJDEForForteInstaller() {
+        InstallPane installPane = new InstallPane(false);
+        setInstallPane(installPane);
+        panes = new WizardPane[] {
+          new IntroPane(),
+          new LocationPane() {
+              public String getDefaultLocation() {
+                if (context.onWindows()) {
+                    // check some default locations
+                    String[] paths = { "c:\\forte4j\\modules",
+                        "c:\\apps\\forte4j\\modules",
+                        "c:\\Program Files\\forte4j\\modules" };
+                    int pathIndex = 0;
+                    for (; pathIndex < paths.length; pathIndex++) {
+                        if (new File(paths[pathIndex]).exists()) return paths[pathIndex];
+                    }
+                    return "c:\\forte4j\\modules";
+                } else {
+                    return "/usr/forte4j/modules";
+                }
+              }
+
+            public void verify() {
+                File forte = new File(location.getText() + "/../lib/openide.jar");
+                installLoc = location.getText();
+                if (!forte.exists() && hasGui()) {
+                    int ret =
+                        JOptionPane.showConfirmDialog
+                        (frame,
+                         "The location you specified does not seem to be a " +
+                         "valid Forte install directory." +
+                         " Continue?", "Confirm Install",
+                         JOptionPane.YES_NO_OPTION,
+                         JOptionPane.QUESTION_MESSAGE);
+                    if (ret != JOptionPane.YES_OPTION) {
+                        Main.exit(-1);
+                    } else {
+                        // do nothing
+                    }
+                }
+              }
+          },
+          installPane,
+          new FinishPane() {
+            public void finalActions() { // todo verify dir ../lib/ext exists?
+                // !!! this should be done with two install locations, not by moving a file
+                new File(installLoc + "/../lib/ext/aspectjrt.jar").delete();
+                new File(installLoc + "/aspectjrt.jar").renameTo(new File((installLoc + "/../lib/ext/aspectjrt.jar")));
+                new File(installLoc + "/aspectjrt.jar").delete();
+            }
+          }
+        };
+    }
+}
+
+class SrcInstaller extends Installer {
+    public String getTitle() { return "AspectJ(TM) Compiler and Core Tools Sources Installer"; }
+
+    public String getPrefix() { return "sources"; }
+
+    public SrcInstaller() {
+        InstallPane installPane = new InstallPane(false);
+        setInstallPane(installPane);
+        panes = new WizardPane[] {
+          new IntroPane(),
+          new LocationPane(),
+          installPane,
+          new FinishPane()
+        };
+    }
+}
+
+
+abstract class Installer {
+    static final String EXIT_MESSAGE = "Are you sure you want to cancel the installation?";
+    static final String EXIT_TITLE = "Exiting installer";
+    /** relative directory in jar from package $installer$.org.aspectj
+        for loading resources - todo must be tracked during build */
+    public static final String RESOURCE_DIR = "resources";
+
+    JFrame frame;
+    InstallContext context;
+    /** special pane that actually does the installation */
+    InstallPane installPane;
+
+    public Installer() {
+    }
+
+    protected void setInstallPane(InstallPane installPane) {
+        this.installPane = installPane;
+    }
+    public InstallPane getInstallPane() {
+        return installPane;
+    }
+
+    /** directly run the install pane, if any */
+    public void run() {
+        if (null != installPane) {
+            installPane.run();
+        }
+    }
+
+    public abstract String getPrefix();
+
+    public void setContext(InstallContext context) {
+        this.context = context;
+        context.installer = this;
+    }
+
+    public InstallContext getContext() {
+        return context;
+    }
+
+    public String getTitle() { return "AspectJ(TM) Installer"; }
+    public int getWidth() { return 640; }
+    public int getHeight() { return 460; }
+
+    protected WizardPane[] panes = new WizardPane[0];
+    public WizardPane[] getPanes() {
+        return panes;
+    }
+
+    public int findPaneIndex(WizardPane pane) {
+        for (int i = 0; i < panes.length; i++) {
+            if (panes[i] == pane) return i;
+        }
+        return -1;
+    }
+
+    Component header, footer, body;
+
+    public void runGUI() {
+        frame = new JFrame(getTitle());
+
+        if (Options.forceError1) {
+            throw new RuntimeException("forced error1 for testing purposes");
+        }
+
+        Dimension size = Toolkit.getDefaultToolkit().getScreenSize();
+
+        int x = (int)(size.getWidth() - getWidth()) / 2;
+        int y = (int)(size.getHeight() - getHeight()) / 2;
+
+        //include a few sanity checks on starting position
+        if (x < 0) x = 0;
+        if (x > 600) x = 600;
+        if (y < 0) y = 0;
+        if (y > 400) y = 400;
+
+        frame.setLocation(x, y);
+        frame.setSize(getWidth(), getHeight());
+        moveToPane(getPanes()[0]);
+        frame.setVisible(true);
+    }
+
+    public void moveToPane(WizardPane pane) {
+        pane.setContext(this.context);
+
+        Dimension size = frame.getContentPane().getSize();
+
+        JPanel contents = new JPanel();
+        contents.setLayout(new BorderLayout());
+        header = makeHeader();
+        contents.add(header, BorderLayout.NORTH);
+
+        body = pane.getPanel();
+        contents.add(body, BorderLayout.CENTER);
+
+        footer = pane.getButtons();
+        contents.add(footer, BorderLayout.SOUTH);
+
+        contents.revalidate();
+        contents.setSize(size);
+
+        frame.setContentPane(contents);
+
+        //XXX deal with threading here?
+        pane.run();
+    }
+
+    public Icon loadImage(String name) {
+        return new javax.swing.ImageIcon(this.getClass().getResource(name));
+    }
+
+    public Component makeHeader() {
+        return new JLabel(loadImage(Installer.RESOURCE_DIR + "/aspectjBanner.gif"));
+    }
+
+    public ActionListener makeNextAction(final WizardPane pane) {
+        int nextPaneIndex = findPaneIndex(pane) + 1;
+        if (nextPaneIndex >= getPanes().length) {
+            return null;
+        }
+
+        final WizardPane nextPane = getPanes()[nextPaneIndex];
+        return new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                pane.finish();
+                moveToPane(nextPane);
+            }
+        };
+    }
+
+    public ActionListener makeBackAction(final WizardPane pane) {
+        int nextPaneIndex = findPaneIndex(pane) - 1;
+        if (nextPaneIndex < 0) {
+            return null;
+        }
+
+        final WizardPane nextPane = getPanes()[nextPaneIndex];
+        return new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                moveToPane(nextPane);
+            }
+        };
+    }
+
+    public ActionListener makeCancelAction(WizardPane pane) {
+        return new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                int ret = JOptionPane.showConfirmDialog(frame, EXIT_MESSAGE, EXIT_TITLE,
+                                                        JOptionPane.YES_NO_OPTION,
+                                                        JOptionPane.QUESTION_MESSAGE);
+                if (ret == JOptionPane.YES_OPTION) {
+                    Main.exit(-1);
+                }
+            }
+        };
+    }
+    public ActionListener makeFinishAction(WizardPane pane) {
+        return new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                Main.exit(0);
+            }
+        };
+    }
+}
+
+
+
+    // willing to go up to 3 levels deep to find either jre or jdk
+
+    // jre\[*\]lib\ext
+    // jdk*\lib\tools.jar
+
+    /*****
+    final static int MAX_DEPTH = 4;
+    public static void findPaths(String prefix, File currentDir, int currentDepth) {
+        if (currentDepth > MAX_DEPTH) return;
+        if (!currentDir.exists() || !currentDir.isDirectory()) return;
+        File [] files = currentDir.listFiles();
+        if (files == null) return;
+        for (int i=0; i<files.length; i++) {
+            if (files[i] == null) continue;
+            if (!files[i].isDirectory()) continue;
+            if (files[i].getName().startsWith(prefix)) {
+                System.out.println("found: " + files[i]);
+            } else {
+                findPaths(prefix, files[i], currentDepth + 1);
+            }
+        }
+    }
+
+    public static void findPaths(String prefix) {
+        File [] files = File.listRoots();
+        for (int i=1; i<files.length; i++) {
+            if (!files[i].isDirectory()) continue;
+            if (files[i].getName().toLowerCase().startsWith(prefix)) {
+                System.out.println("found: " + files[i]);
+            } else {
+                findPaths(prefix, files[i], 1);
+            }
+        }
+    }
+    *****/
+
+class InstallContext {
+    public InstallContext(Map properties) {
+        this.properties = properties;
+        properties.put("user.home", System.getProperty("user.home"));
+        //System.out.println("new install context");
+    }
+
+    private File outputDir;
+    public void setOutputDir(File outputDir) {
+        this.outputDir = outputDir;
+
+        properties.put("installer.output.dir", outputDir.getAbsolutePath());
+        properties.put("installer.output.dir.bin", new File(outputDir, "bin").getAbsolutePath());
+        properties.put("installer.output.dir.doc", new File(outputDir, "doc").getAbsolutePath());
+        properties.put("installer.output.aspectjrt", new File(new File(outputDir, "lib"), "aspectjrt.jar").getAbsolutePath());
+        properties.put("installer.output.readme", new File(outputDir, "README-" + installer.getPrefix().toUpperCase()+".html").getAbsolutePath());
+    }
+
+    public File getOutputDir() {
+        return outputDir;
+    }
+
+    private boolean hasGui;
+    public File javaPath;
+    public File toolsJarPath;
+
+    public Installer installer;
+
+    private Map properties;
+
+    public boolean hasGui() {
+        return hasGui;
+    }
+
+    public void setHasGui(boolean hasGui) {
+        if (this.hasGui != hasGui) {
+            this.hasGui = hasGui;
+        }
+    }
+
+    public Font getFont() {
+        return new Font("Serif", Font.PLAIN, 14);
+    }
+
+    public String getOS() {
+        return System.getProperty("os.name");
+    }
+
+    public boolean onOS2() {
+        return getOS().equals("OS2") || getOS().equals("OS/2");
+    }
+
+    public boolean onWindows() {
+        return getOS().startsWith("Windows") || onOS2();
+    }
+
+    public boolean onWindowsPro() {
+        return getOS().equals("Windows NT") || getOS().equals("Windows 2000");
+    }
+
+    public boolean onMacintosh() {
+        return getOS().startsWith("Mac");
+    }
+
+    public boolean onUnix() {
+        return !onMacintosh() && !onWindows();
+    }
+
+    static final String[] TEXT_EXTENSIONS = {
+        ".txt", ".text", ".htm", ".html", ".java", ".ajava", "README", ".lst"
+    };
+
+    public boolean isTextFile(File file) {
+        String name = file.getName();
+
+        for (int i=0; i < TEXT_EXTENSIONS.length; i++) {
+            if (name.endsWith(TEXT_EXTENSIONS[i])) return true;
+        }
+
+        return false;
+    }
+
+    public void handleException(Throwable e) {
+        System.out.println("internal error: " + e.toString());
+        e.printStackTrace();
+        if (hasGui()) {
+            JOptionPane.showMessageDialog(installer.frame, e.toString(),
+            "Unexpected Exception", JOptionPane.ERROR_MESSAGE);
+        }
+    }
+
+    final static String OVERWRITE_MESSAGE = "Overwrite file ";
+    final static String OVERWRITE_TITLE = "Overwrite?";
+
+    final static String[] OVERWRITE_OPTIONS = {
+        "Yes", "No", "Yes to all" //, "No to all"
+    };
+
+    final static int OVERWRITE_YES = 0;
+    final static int OVERWRITE_NO = 1;
+    final static int OVERWRITE_ALL = 2;
+    //final static int OVERWRITE_NONE = 3;
+
+    int overwriteState = OVERWRITE_NO;
+    boolean shouldOverwrite(final File file) {
+        //System.out.println("overwrite: " + file + " state " + overwriteState);
+        if (overwriteState == OVERWRITE_ALL) return true;
+        //if (overwriteState == OVERWRITE_NONE) return false;
+
+        try {
+            SwingUtilities.invokeAndWait(new Runnable() {
+                public void run() {
+                    int ret = JOptionPane.showOptionDialog(installer.frame,
+                          OVERWRITE_MESSAGE+file.getPath(), OVERWRITE_TITLE,
+                          JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null,
+                          OVERWRITE_OPTIONS, OVERWRITE_OPTIONS[OVERWRITE_YES]);
+
+                    overwriteState = ret;
+                }
+            });
+        } catch (InvocationTargetException ite) {
+            handleException(ite.getTargetException());
+        } catch (InterruptedException ie) {
+        }
+
+        return overwriteState == OVERWRITE_YES || overwriteState == OVERWRITE_ALL;
+    }
+
+
+    public Map getProperties() {
+        return properties;
+    }
+}
+
+abstract class WizardPane {
+    InstallContext context;
+
+    protected JButton backButton = null;
+    protected JButton nextButton = null;
+    protected JButton cancelButton = null;
+
+    public void setContext(InstallContext context) { this.context = context; }
+
+    public abstract JPanel makePanel();
+
+    protected JTextArea makeTextArea(String data) {
+        JTextArea text = new JTextArea(data);
+        text.setOpaque(false);
+        text.setFont(context.getFont());
+        text.setEditable(false);
+        return text;
+    }
+
+    /** @return false only if there is an InstallContext saying there is no GUI */
+    protected boolean hasGui() {
+        final InstallContext icontext = context;
+        return ((null == icontext) || icontext.hasGui());
+    }
+
+    public static String stringFromStream(InputStream stream) throws IOException {
+        BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "US-ASCII"));
+
+        StringBuffer ret = new StringBuffer();
+        int data;
+        while ( (data = reader.read()) != -1) {
+            ret.append( (char)data );
+        }
+        return ret.toString();
+    }
+
+    public static String removeHead(String text) {
+        int startIndex = text.indexOf("<head>");
+        int stopIndex = text.indexOf("</head>");
+        if (startIndex == -1 || stopIndex == -1) return text;
+        stopIndex += 7;
+        return text.substring(0, startIndex) + text.substring(stopIndex);
+    }
+
+    static String styleHeader = "<head></head>";/*<STYLE TYPE=\"text/css\"><!--\n" +
+    " h2 {\n" +
+	"  	font-size: x-large;\n" +
+    "   font-family: Serif;\n" +
+    "   font-weight: normal;\n" +
+    " }\n" +
+    " p {\n" +
+    "   font-family: Serif;\n" +
+    "   font-weight: normal;\n" +
+    //"   color:black;\n" +
+    "}</head>\n";*/
+
+
+    public static String applyProperties(String text, Map map) {
+        // ${name} -> map.get(name).toString()
+        int lastIndex = 0;
+        StringBuffer buf = new StringBuffer();
+
+        int startIndex;
+        while ( (startIndex = text.indexOf("${", lastIndex)) != -1) {
+            int endIndex = text.indexOf('}', startIndex);
+            //XXX internal error here
+            if (endIndex == -1) break;
+            buf.append(text.substring(lastIndex, startIndex));
+            String key = text.substring(startIndex+2, endIndex);
+            lastIndex = endIndex+1;
+            Object replaceText = map.get(key);
+            //System.out.println("key: " + key + " -> " + replaceText);
+            if (replaceText == null) replaceText = "NOT_FOUND";
+            buf.append(replaceText.toString());
+        }
+        buf.append(text.substring(lastIndex));
+
+        return buf.toString();
+    }
+
+    public String applyProperties(String text) {
+        return applyProperties(text, context.getProperties());
+    }
+
+    protected String loadText(String filename) {
+        String fullname = Installer.RESOURCE_DIR + "/" + filename;
+        //context.installer.getPrefix() + "-" + filename;
+
+        try {
+            String text = stringFromStream(getClass().getResourceAsStream(fullname));
+            text = styleHeader + removeHead(text);
+            text = applyProperties(text);
+            //System.out.println(text);
+            return text;
+        } catch (IOException e) {
+            context.handleException(e);
+            return "";
+        }
+    }
+
+    protected JEditorPane makeHTMLArea(String filename) {
+        JEditorPane editorPane = new JEditorPane("text/html", loadText(filename));
+        /* {
+            public void paint(Graphics g) {
+                Graphics2D g2 = (Graphics2D)g;
+                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+                super.paint(g2);
+            }
+        };*/
+        editorPane.setEditable(false);
+        editorPane.setOpaque(false);
+        return editorPane;
+    }
+
+    protected void setHTMLArea(JEditorPane pane, String filename) {
+        pane.setText(loadText(filename));
+    }
+
+
+    protected JPanel makeLocationBox(String label, JTextField textField, JButton browseButton) {
+        JPanel box = new JPanel();
+        box.setLayout(new BoxLayout(box, BoxLayout.X_AXIS));
+
+        textField.setFont(context.getFont());
+        textField.selectAll();
+        box.add(textField);
+
+        box.add(browseButton);
+        Border border = BorderFactory.createTitledBorder(label);
+        final int INSET = 8;
+        border = new CompoundBorder(border, new EmptyBorder(1, INSET, INSET, INSET));
+        box.setBorder(border);
+
+        return box;
+    }
+
+
+    private JPanel panel = null;
+    public JPanel getPanel() {
+        if (panel == null) {
+            panel = makePanel();
+            panel.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10));
+        }
+        return panel;
+    }
+
+    protected void setListener(JButton button, ActionListener listener) {
+        if (listener == null) {
+            button.setEnabled(false);
+        } else {
+            button.addActionListener(listener);
+        }
+    }
+
+    protected Component makeButtons(Installer installer) {
+        JPanel panel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
+
+        backButton = new JButton("Back");
+        setListener(backButton, installer.makeBackAction(this));
+        panel.add(backButton);
+
+        nextButton = new JButton("Next");
+        setListener(nextButton, installer.makeNextAction(this));
+        panel.add(nextButton); //.setDefaultCapable(true);
+
+        JLabel space = new JLabel();
+        space.setPreferredSize(new Dimension(20, 0));
+        panel.add(space);
+
+        cancelButton = new JButton("Cancel");
+        setListener(cancelButton, installer.makeCancelAction(this));
+        panel.add(cancelButton);
+
+        return panel;
+    }
+
+    private Component buttons = null;
+    public Component getButtons() {
+        if (buttons == null) {
+            buttons = makeButtons(context.installer);
+            //buttons.setBorder(BorderFactory.createEmptyBorder(0, 10, 0, 10));
+        }
+        context.installer.frame.getRootPane().setDefaultButton(nextButton);
+        return buttons;
+    }
+
+    public void finish() {
+        if (Options.forceError2) {
+            throw new RuntimeException("forced error2 for testing purposes");
+        }
+    }
+    public void run() {}
+}
+
+class IntroPane extends WizardPane {
+    public JPanel makePanel() {
+        Component text = makeHTMLArea("intro.html");
+
+        JPanel panel = new JPanel(new BorderLayout());
+        panel.add(text);
+        return panel;
+    }
+}
+
+class FinishPane extends WizardPane {
+    public JPanel makePanel() {
+        Component text = makeHTMLArea("finish.html");
+
+        JPanel panel = new JPanel(new BorderLayout());
+        panel.add(text);
+        finalActions();
+        return panel;
+    }
+
+    public Component makeButtons(Installer installer) {
+        Component ret = super.makeButtons(installer);
+        nextButton.setText("Finish");
+        nextButton.setEnabled(true);
+        nextButton.addActionListener(installer.makeFinishAction(this));
+        backButton.setEnabled(false);
+        cancelButton.setEnabled(false);
+        return ret;
+    }
+
+    public void finalActions() { }
+}
+
+
+class LocationPane extends WizardPane implements ActionListener {
+    //XXX need more sophisticated default location finding
+    //XXX would like to find the place they last chose...
+    public String getDefaultLocation() {
+        if (context.onWindows()) {
+            //XXX hard-coded majorminor version needs to be fixed by 1.1 release
+            return "c:\\aspectj1.1";
+        } else {
+            return new File(System.getProperty("user.home"), "aspectj1.1").getAbsolutePath();
+        }
+    }
+
+    protected JTextField location;
+
+    public JPanel makePanel() {
+        Component text = makeHTMLArea("location.html");
+
+        location = new JTextField(getDefaultLocation());
+        JButton browse = new JButton("Browse...");
+        browse.addActionListener(this);
+
+        JPanel locationBox = makeLocationBox("installation directory", location, browse);
+
+        GridBagLayout bag = new GridBagLayout();
+        GridBagConstraints c = new GridBagConstraints();
+
+        JPanel panel = new JPanel(bag);
+        c.fill = GridBagConstraints.BOTH;
+        c.weightx = 1.0;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        bag.setConstraints(text, c);
+        panel.add(text);
+
+        c.weighty = 1.0;
+        c.fill = GridBagConstraints.HORIZONTAL;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        bag.setConstraints(locationBox, c);
+        panel.add(locationBox);
+
+        //XXX set next button to read install
+        //context.nextButton.setText("Install");
+
+        return panel;
+    }
+
+    public Component makeButtons(Installer installer) {
+        Component ret = super.makeButtons(installer);
+        nextButton.setText("Install");
+        return ret;
+    }
+
+    public void actionPerformed(ActionEvent e) {
+        JFileChooser chooser = new JFileChooser(); // {
+        //    public void approveSelection() {
+        //        System.out.println("approved selection");
+        //    }
+        //}; //field.getText());
+        chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
+        int returnVal = chooser.showDialog(location, "Select");
+        if(returnVal == JFileChooser.APPROVE_OPTION) {
+            File file = chooser.getSelectedFile();
+            if (!file.isDirectory()) file = file.getParentFile();
+            String name = file.getPath();
+            location.setText(name);
+            location.selectAll();
+        }
+    }
+
+    /**
+     * Override to do any additional checks.
+     */
+    protected void verify() {}
+
+    public void finish() {
+        verify();
+        context.setOutputDir(new File(location.getText()));
+    }
+}
+
+class ConfigureLauncherPane extends WizardPane {
+    /*
+    //XXX check that the returned file is valid
+    public String getDefaultJavaLocation() {
+        String name = "java";
+        if (context.onWindows()) name += ".exe";
+
+        if (Options.verbose) {
+            System.out.println("java.home: " + System.getProperty("java.home"));
+            System.out.println("  java: " + new File(new File(System.getProperty("java.home"), "bin"), name));
+            System.out.println("  java: " + new File(new File(System.getProperty("java.home"), "bin"), name).getPath());
+        }
+
+        return new File(new File(System.getProperty("java.home"), "bin"), name).getPath();
+    }
+    */
+
+    public String getDefaultJavaHomeLocation() {
+        if (!Options.forceHandConfigure) {
+            File javaHome = findJavaHome();
+            if (javaHome != null) return javaHome.getPath();
+        }
+        return null;
+    }
+
+    public void chooseFile(JTextField field) {
+        JFileChooser chooser = new JFileChooser(); //field.getText());
+        chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+        int returnVal = chooser.showDialog(field, "Select");
+        if(returnVal == JFileChooser.APPROVE_OPTION) {
+            String name = chooser.getSelectedFile().getPath();
+            field.setText(name);
+            field.selectAll();
+        }
+    }
+
+
+    public ActionListener makeJavaLocationBrowseListener() {
+        return new ActionListener() {
+            public void actionPerformed(ActionEvent e) {
+                chooseFile(javaLocation);
+            }
+        };
+    }
+
+//     public ActionListener makeToolsJarLocationBrowseListener() {
+//         return new ActionListener() {
+//             public void actionPerformed(ActionEvent e) {
+//                 chooseFile(toolsJarLocation);
+//             }
+//         };
+//     }
+
+
+    private JTextField javaLocation;
+    //private JTextField toolsJarLocation;
+
+    public JPanel makePanel() {
+        String javaPath = getDefaultJavaHomeLocation();
+        //String toolsJarPath = getDefaultToolsJarLocation();
+
+        Component text;
+        if (javaPath == null) {
+            javaPath = "<java home not found>";
+            text = makeHTMLArea("configure-hand.html");
+        } else {
+            text = makeHTMLArea("configure-auto.html");
+        }
+
+        javaLocation = new JTextField(javaPath);
+        JButton javaLocationBrowse = new JButton("Browse...");
+        javaLocationBrowse.addActionListener(makeJavaLocationBrowseListener());
+
+        JPanel javaLocationBox = makeLocationBox("java home directory", javaLocation, javaLocationBrowse);
+
+
+//         toolsJarLocation = new JTextField(toolsJarPath);
+//         JButton toolsJarLocationBrowse = new JButton("Browse...");
+//         toolsJarLocationBrowse.addActionListener(makeToolsJarLocationBrowseListener());
+
+//         JPanel toolsJarLocationBox = makeLocationBox("full path to tools.jar", toolsJarLocation, toolsJarLocationBrowse);
+
+        GridBagLayout bag = new GridBagLayout();
+        GridBagConstraints c = new GridBagConstraints();
+
+        JPanel panel = new JPanel(bag);
+        c.fill = GridBagConstraints.BOTH;
+        c.weightx = 1.0;
+        c.weighty = 1.0;
+        //c.ipady = 10;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        bag.setConstraints(text, c);
+        panel.add(text);
+
+        c.weighty = 0.0;
+        //c.fill = GridBagConstraints.VERTICAL;
+        bag.setConstraints(javaLocationBox, c);
+        panel.add(javaLocationBox);
+
+//         c.weighty = 0.25;
+//         JLabel space = new JLabel();
+//         bag.setConstraints(space, c);
+//         panel.add(space);
+
+//         c.weighty = 0.0;
+//         bag.setConstraints(toolsJarLocationBox, c);
+//         panel.add(toolsJarLocationBox);
+
+        c.weighty = 0.5;
+        JLabel space = new JLabel();
+        bag.setConstraints(space, c);
+        panel.add(space);
+
+        return panel;
+    }
+
+    public void finish() {
+        context.javaPath = new File(javaLocation.getText());
+//         context.toolsJarPath = new File(toolsJarLocation.getText());
+
+        //XXX need much more work on helping the user get these paths right
+//         if (context.javaPath.isDirectory()) {
+//             context.javaPath = new File(context.javaPath, "java");
+//         }
+//         if (context.toolsJarPath.isDirectory()) {
+//             context.toolsJarPath = new File(context.toolsJarPath, "tools.jar");
+//         }
+    }
+
+
+    //XXX add user.home to prefixes in a rational way
+    public static final String[] windowsPaths = {
+        "c:\\jdk", "c:\\apps\\jdk", "${user.home}\\jdk"
+    };
+
+    public static final String[] unixPaths = {
+        "/usr/local/bin/jdk", "/usr/bin/jdk", "/usr/bin/jdk", "${user.home}/jdk"
+    };
+
+    public static final String[] suffixes = {
+        "1.3.1", "1.3", "1.2", "13", "12", "2", "", "1.4"
+    };
+
+    public static boolean windows = true;
+
+    public boolean isLegalJavaHome(File home) {
+        File bin = new File(home, "bin");
+        return new File(bin, "java").isFile() || new File(bin, "java.exe").isFile();
+    }
+
+    public boolean isLegalJDKHome(File home) {
+        File lib = new File(home, "lib");
+        return new File(lib, "tools.jar").isFile();
+    }
+
+
+    public File findJavaHome() {
+        String s = System.getProperty("java.home");
+        File javaHome = null;
+        if (s != null) {
+            javaHome = new File(s);
+            if (isLegalJDKHome(javaHome)) return javaHome;
+            if (isLegalJavaHome(javaHome)) {
+                File parent = javaHome.getParentFile();
+                if (parent != null && isLegalJDKHome(parent)) return parent;
+            }
+        }
+
+        String[] paths;
+        if (windows) {
+            paths = windowsPaths;
+        } else {
+            paths = unixPaths;
+        }
+
+        for (int suffixIndex = 0; suffixIndex < suffixes.length; suffixIndex++) {
+            String suffix = suffixes[suffixIndex];
+            for (int prefixIndex = 0; prefixIndex < paths.length; prefixIndex++) {
+                String prefix = paths[prefixIndex];
+                prefix = applyProperties(prefix);
+                File test = new File(prefix+suffix);
+                if (isLegalJavaHome(test)) {
+                    if (isLegalJDKHome(test)) return test;
+                    else if (javaHome == null) javaHome = test;
+                }
+            }
+        }
+        return javaHome;
+    }
+}
+
+
+class InstallPane extends WizardPane {
+    private JProgressBar progressBar;
+    private JTextField progressItem;
+    private JEditorPane message;
+
+    private boolean makeLaunchScripts = false;
+
+    public InstallPane(boolean makeLaunchScripts) {
+        this.makeLaunchScripts = makeLaunchScripts;
+    }
+
+    public JPanel makePanel() {
+        message = makeHTMLArea("install-start.html");
+
+        progressBar = new JProgressBar();
+
+        progressItem = new JTextField();
+        progressItem.setOpaque(false);
+        progressItem.setFont(context.getFont());
+        progressItem.setEditable(false);
+
+
+        GridBagLayout bag = new GridBagLayout();
+        GridBagConstraints c = new GridBagConstraints();
+
+        JPanel panel = new JPanel(bag);
+        c.fill = GridBagConstraints.BOTH;
+        c.weightx = 1.0;
+        c.weighty = 1.0;
+        //c.ipady = 10;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        bag.setConstraints(message, c);
+        panel.add(message);
+
+        c.weighty = 0.0;
+        //c.fill = GridBagConstraints.VERTICAL;
+        bag.setConstraints(progressBar, c);
+        panel.add(progressBar);
+
+        c.weighty = 0.1;
+        JLabel space = new JLabel();
+        bag.setConstraints(space, c);
+        panel.add(space);
+
+        c.weighty = 0.0;
+        bag.setConstraints(progressItem, c);
+        panel.add(progressItem);
+
+        c.weighty = 0.5;
+        space = new JLabel();
+        bag.setConstraints(space, c);
+        panel.add(space);
+
+        return panel;
+    }
+
+    class InstallRunner implements Runnable {
+        public InstallRunner() {}
+
+        public void run() {
+            try {
+                new CurrentJarUnpacker(context, InstallPane.this).unpack(Installer.RESOURCE_DIR + "/contents.txt", context.getOutputDir());
+
+                if (makeLaunchScripts) {
+                    LaunchScriptMaker lsm = new LaunchScriptMaker(context);
+                    lsm.writeScript("ajc");
+                    //lsm.writeScript("ajdoc");
+                    //lsm.writeScript("ajdb");
+                    lsm.writeScript("ajbrowser");
+                }
+                if (hasGui()) {
+                  progressBar.setValue(100);
+                  setHTMLArea(message, "install-finish.html");
+                }
+            } catch (IOException ioe) {
+                context.handleException(ioe);
+            }
+
+            if (hasGui()) {
+                cancelButton.setEnabled(false);
+                nextButton.setEnabled(true);
+            }
+        }
+    }
+
+    public Component makeButtons(Installer installer) {
+        Component ret = super.makeButtons(installer);
+        //nextButton.setText("Finish");
+        nextButton.setEnabled(false);
+        //nextButton.addActionListener(installer.makeFinishAction(this));
+        backButton.setEnabled(false);
+        return ret;
+    }
+
+
+    public void run() {
+        Thread thread = new Thread(new InstallRunner());
+        thread.start();
+    }
+
+    public void progressMessage(final String message) {
+        if (!hasGui()) {
+            return;
+        }
+        try {
+            //XXX performance tradeoff between invokeAndWait and invokeLater...
+            SwingUtilities.invokeAndWait(new Runnable() {
+                    public void run() {
+                        progressItem.setText(message);
+                    }
+                });
+        } catch (InvocationTargetException ite) {
+            context.handleException(ite.getTargetException());
+        } catch (InterruptedException ie) {
+        }
+    }
+
+    int nBytes = 0;
+    int bytesWritten = 0;
+    public void progressBytesWritten(int bytes) {
+        if (!hasGui()) {
+            return;
+        }
+        bytesWritten += bytes;
+        final int PCT = (int)(100.0 *  bytesWritten / nBytes);
+        //System.out.println("bytesWritten: " + bytesWritten);
+        try {
+            //XXX performance tradeoff between invokeAndWait and invokeLater...
+            SwingUtilities.invokeAndWait(new Runnable() {
+                public void run() {
+                    progressBar.setValue(PCT);
+                }
+            });
+        } catch (InvocationTargetException ite) {
+            context.handleException(ite.getTargetException());
+        } catch (InterruptedException ie) {
+        }
+    }
+}
+
+class CurrentJarUnpacker {
+    InstallContext context;
+    InstallPane installPane;
+
+    public CurrentJarUnpacker(InstallContext context, InstallPane installPane) {
+        this.context = context;
+        this.installPane = installPane;
+    }
+
+    public File makeOutputFile(String name, File outputFile) {
+        int index;
+        int lastIndex = 0;
+
+        while ( (index = name.indexOf('/', lastIndex)) != -1) {
+            outputFile = new File(outputFile, name.substring(lastIndex, index));
+            lastIndex = index + 1;
+        }
+
+        return new File(outputFile, name.substring(lastIndex));
+    }
+
+    final static int BUF_SIZE = 4096;
+
+    public void writeStream(InputStream zis, File outputFile) throws IOException {
+        if (outputFile.exists()) {
+            if (!context.shouldOverwrite(outputFile)) return;
+        }
+
+        installPane.progressMessage("writing " + outputFile.getAbsolutePath());
+
+        outputFile.getParentFile().mkdirs();
+
+        if (context.isTextFile(outputFile)) {
+            writeTextStream(zis, outputFile);
+        } else {
+            writeBinaryStream(zis, outputFile);
+        }
+    }
+
+    public void writeBinaryStream(InputStream zis, File outputFile) throws IOException {
+        byte[] buffer = new byte[BUF_SIZE];
+        int nRead = 0;
+
+        OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile));
+
+        while ( (nRead = zis.read(buffer)) != -1) {
+            os.write(buffer, 0, nRead);
+            installPane.progressBytesWritten(nRead);
+        }
+        os.close();
+    }
+
+    public void writeTextStream(InputStream zis, File outputFile) throws IOException {
+        BufferedWriter os = new BufferedWriter(new FileWriter(outputFile));
+        BufferedReader r = new BufferedReader(new InputStreamReader(zis, "US-ASCII"));
+
+        String l;
+        while ( (l = r.readLine()) != null) {
+            os.write(l);
+            os.newLine();
+            installPane.progressBytesWritten(l.length() + 1);
+        }
+        os.close();
+    }
+
+    public void writeResource(String name, File outputDir) throws IOException {
+        File outputFile = makeOutputFile(name, outputDir);
+        //System.out.println("finding name: " + name);
+        writeStream(getClass().getResourceAsStream("/" + name), outputFile);
+    }
+
+    public void unpack(String contentsName, File outputDir) throws IOException {
+        URL url = getClass().getResource(contentsName);
+        InputStream stream = url.openStream();
+        BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "US-ASCII"));
+
+        String line = reader.readLine();
+        installPane.nBytes = Integer.parseInt(line);
+
+        while ( (line = reader.readLine()) != null) {
+            writeResource(line, outputDir);
+        }
+
+        installPane.progressMessage("done writing");
+    }
+}
+
+class LaunchScriptMaker {
+    static final String toolsPackage = "org.aspectj.tools";
+
+    InstallContext context;
+    public LaunchScriptMaker(InstallContext context) {
+        this.context = context;
+    }
+
+    private void writeWindowsHeader(String className, PrintStream ps) {
+        ps.println("@echo off");
+        ps.println("REM This file generated by AspectJ installer");
+        ps.println("REM Created on "+new java.util.Date()+" by "+
+                   System.getProperty("user.name"));
+        ps.println("");
+        ps.println("if \"%JAVA_HOME%\" == \"\" set JAVA_HOME=" +
+                   context.javaPath.getAbsolutePath());
+        ps.println("if \"%ASPECTJ_HOME%\" == \"\" set ASPECTJ_HOME=" +
+                   context.getOutputDir().getAbsolutePath());
+        ps.println("");
+
+        ps.println("if exist \"%JAVA_HOME%\\bin\\java.exe\" goto haveJava");
+        ps.println("if exist \"%JAVA_HOME%\\bin\\java.bat\" goto haveJava");
+        ps.println("if exist \"%JAVA_HOME%\\bin\\java\" goto haveJava");
+
+        ps.println("echo java does not exist as %JAVA_HOME%\\bin\\java");
+        ps.println("echo please fix the JAVA_HOME environment variable");
+        ps.println(":haveJava");
+        ps.println("\"%JAVA_HOME%\\bin\\java\" -classpath " +
+                   "\"%ASPECTJ_HOME%\\lib\\aspectjtools.jar;%JAVA_HOME%\\lib\\tools.jar;%CLASSPATH%\""+
+                   " -Xmx64M " + className + //" -defaultClasspath " + "\"%CLASSPATH%\"" +
+                   " " + makeScriptArgs(false));
+    }
+
+    private void writeUnixHeader(String className, PrintStream ps) {
+        File binsh = new File(File.separator+"bin", "sh");
+        if (binsh.canRead()) {
+            ps.println("#!"+binsh.getPath());
+        }
+        ps.println("# This file generated by AspectJ installer");
+        ps.println("# Created on "+new java.util.Date()+" by "+
+                   System.getProperty("user.name"));
+        ps.println("");
+        ps.println("if [ \"$JAVA_HOME\" = \"\" ] ; then JAVA_HOME=" +
+                   quote(true, false, context.javaPath.getAbsolutePath()));
+        ps.println("fi");
+        ps.println("if [ \"$ASPECTJ_HOME\" = \"\" ] ; then ASPECTJ_HOME=" +
+                   quote(true, false, context.getOutputDir()));
+        ps.println("fi");
+        ps.println("");
+        String sep = File.pathSeparator;
+
+        ps.println("\"$JAVA_HOME/bin/java\" -classpath "+
+                   "\"$ASPECTJ_HOME/lib/aspectjtools.jar" + sep +
+                   "$JAVA_HOME/lib/tools.jar" + sep +
+                   "$CLASSPATH\""+
+                   " -Xmx64M " + className +
+                   " " + makeScriptArgs(true));
+    }
+
+
+    private void makeExecutable(File file) {
+        try {
+            Runtime curRuntime = Runtime.getRuntime();
+            curRuntime.exec("chmod 777 " + quote(true, false, file));
+        } catch (Throwable t) {
+            // ignore any errors that occur while trying to chmod
+        }
+    }
+
+
+
+    private String makeScriptArgs(boolean unixStyle) {
+        if (unixStyle) {
+            return "\"$@\"";
+        } else if (context.onWindowsPro()) {
+            return "%*";
+        } else {
+            return "%1 %2 %3 %4 %5 %6 %7 %8 %9";
+        }
+    }
+
+    private String quote(boolean unixStyle, boolean forceQuotes, File file) {
+        return quote(unixStyle, forceQuotes, file.getAbsolutePath());
+    }
+    private String quote(boolean unixStyle, boolean forceQuotes, String s) {
+        if (context.onWindows() && unixStyle) {
+            s = s.replace('\\', '/');
+        }
+
+        if (!forceQuotes && s.indexOf(' ') == -1) return s;
+        return "\""+s+"\"";
+    }
+
+    private File makeScriptFile(String name, boolean unixStyle) throws IOException {
+        if (!unixStyle) {
+            if (context.onOS2()) {
+                name += ".cmd";
+            } else if (context.onWindows()) {
+                name += ".bat";
+            }
+        }
+
+        //XXX probably want a context.getOutputBinDir()
+        File bindir = new File(context.getOutputDir(), "bin");
+        bindir.mkdirs();
+        File file = new File(bindir, name);
+        return file;
+    }
+
+    private PrintStream getPrintStream(File file) throws IOException {
+        return new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
+    }
+
+    String makeClassPathVar(boolean unixStyle) {
+        if (unixStyle) {
+            return "$CLASSPATH";
+        } else {
+            return "%CLASSPATH%";
+        }
+    }
+
+    public String makeClassPath(boolean unixStyle) throws IOException {
+        return context.toolsJarPath.getAbsolutePath() + File.pathSeparator +
+               //XXX want context.getOutputLibDir()
+            new File(new File(context.getOutputDir(), "lib"), "aspectjtools.jar").getAbsolutePath()
+            + File.pathSeparator + makeClassPathVar(unixStyle);
+    }
+
+    public void writeScript(String className, PrintStream ps, boolean unixStyle) throws IOException {
+        if (unixStyle) writeUnixHeader(className, ps);
+        else writeWindowsHeader(className, ps);
+
+        /*
+        ps.print(quote(unixStyle, false, context.javaPath.getAbsolutePath()));
+        ps.print(" ");
+        ps.print("-classpath ");
+        ps.print(quote(unixStyle, true, makeClassPath(unixStyle)));
+        ps.print(" ");
+        ps.print("-Xmx64M ");
+        ps.print(className);
+        ps.print(" ");
+        ps.print(makeScriptArgs(unixStyle));
+        */
+    }
+
+    public void writeScript(String className, boolean unixStyle) throws IOException {
+        File file = makeScriptFile(className, unixStyle);
+        if (!checkExistingFile(file)) return;
+        PrintStream ps = getPrintStream(file);
+        writeScript(toolsPackage + '.' + className + ".Main", ps, unixStyle);
+        ps.close();
+        //??? unixStyle vs. onUnix()
+        if (context.onUnix()) makeExecutable(file);
+    }
+
+    public boolean checkExistingFile(File file) {
+        if (!file.exists()) return true;
+
+        return context.shouldOverwrite(file);
+    }
+
+    /*
+    final static String OVERWRITE_MESSAGE = "Overwrite launch script ";
+    final static String OVERWRITE_TITLE = "Overwrite?";
+
+    final static String[] OVERWRITE_OPTIONS = {
+        "Yes", "No", "Yes to all", "No to all"
+    };
+
+    final static int OVERWRITE_YES = 0;
+    final static int OVERWRITE_NO = 1;
+    final static int OVERWRITE_ALL = 2;
+    final static int OVERWRITE_NONE = 3;
+
+    int overwriteState = OVERWRITE_NO;
+    boolean shouldOverwrite(final File file) {
+        if (overwriteState == OVERWRITE_ALL) return true;
+        if (overwriteState == OVERWRITE_NONE) return false;
+
+        try {
+            SwingUtilities.invokeAndWait(new Runnable() {
+                public void run() {
+                    int ret = JOptionPane.showOptionDialog(context.installer.frame,
+                          OVERWRITE_MESSAGE+file.getPath(), OVERWRITE_TITLE,
+                          JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE, null,
+                          OVERWRITE_OPTIONS, OVERWRITE_OPTIONS[OVERWRITE_YES]);
+
+                    overwriteState = ret;
+                }
+            });
+        } catch (InvocationTargetException ite) {
+            context.handleException(ite.getTargetException());
+        } catch (InterruptedException ie) {
+        }
+
+        return overwriteState == OVERWRITE_YES || overwriteState == OVERWRITE_ALL;
+    }
+    */
+
+
+    public void writeScript(String className) throws IOException {
+        writeScript(className, true);
+        if (context.onWindows()) {
+            writeScript(className, false);
+        }
+    }
+}
+
+
+class JarUnpacker {
+    InstallContext context;
+    InstallPane installPane;
+
+    public JarUnpacker(InstallContext context, InstallPane installPane) {
+        this.context = context;
+        this.installPane = installPane;
+    }
+
+    public File makeOutputFile(String name, File outputFile) {
+        int index;
+        int lastIndex = 0;
+
+        while ( (index = name.indexOf('/', lastIndex)) != -1) {
+            outputFile = new File(outputFile, name.substring(lastIndex, index));
+            lastIndex = index + 1;
+        }
+
+        return new File(outputFile, name.substring(lastIndex));
+    }
+
+    final static int BUF_SIZE = 4096;
+
+    public void writeStream(ZipInputStream zis, File outputFile) throws IOException {
+        if (outputFile.exists()) {
+            if (!context.shouldOverwrite(outputFile)) return;
+        }
+
+        installPane.progressMessage("writing " + outputFile.getAbsolutePath());
+
+        outputFile.getParentFile().mkdirs();
+
+        if (context.isTextFile(outputFile)) {
+            writeTextStream(zis, outputFile);
+        } else {
+            writeBinaryStream(zis, outputFile);
+        }
+    }
+
+    public void writeBinaryStream(ZipInputStream zis, File outputFile) throws IOException {
+        byte[] buffer = new byte[BUF_SIZE];
+        int nRead = 0;
+
+        OutputStream os = new BufferedOutputStream(new FileOutputStream(outputFile));
+
+        while ( (nRead = zis.read(buffer)) != -1) {
+            os.write(buffer, 0, nRead);
+            installPane.progressBytesWritten(nRead);
+        }
+        os.close();
+    }
+
+    public void writeTextStream(ZipInputStream zis, File outputFile) throws IOException {
+        BufferedWriter os = new BufferedWriter(new FileWriter(outputFile));
+        BufferedReader r = new BufferedReader(new InputStreamReader(zis, "US-ASCII"));
+
+        String l;
+        while ( (l = r.readLine()) != null) {
+            os.write(l);
+            os.newLine();
+            installPane.progressBytesWritten(l.length() + 1);
+        }
+        os.close();
+    }
+
+    public void writeEntry(ZipInputStream zis, ZipEntry entry, File outputDir) throws IOException {
+        if (entry.isDirectory()) return;
+
+        String name = entry.getName();
+        File outputFile = makeOutputFile(name, outputDir);
+        writeStream(zis, outputFile);
+    }
+
+    public void unpack(String jarName, File outputDir) throws IOException {
+        URL url = getClass().getResource(jarName);
+        InputStream stream = url.openStream();
+        ZipInputStream zis = new ZipInputStream(stream);
+        int i = 0;
+
+        ZipEntry entry;
+        while ((entry = zis.getNextEntry()) != null) {
+            final String name = entry.getName();
+            writeEntry(zis, entry, outputDir);
+            //
+        }
+        installPane.progressMessage("done writing");
+    }
+}
+
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/AJInstaller.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/AJInstaller.java
new file mode 100644
index 000000000..4dd35c4b8
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/AJInstaller.java
@@ -0,0 +1,330 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+//XXX INCLUDES CODE FROM ANT -- UNDER APACHE LICENSE
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.types.*;
+import java.io.*;
+import java.util.zip.ZipOutputStream;
+import java.util.*;
+import java.util.zip.*;
+import org.apache.tools.ant.taskdefs.*;
+import org.apache.tools.ant.*;
+
+public class AJInstaller extends MatchingTask {
+    static final String INCLUDE_CLASSES = "$installer$/org/aspectj/*.class";
+    static final String MAIN_CLASS = "$installer$.org.aspectj.Main";
+    static final String CONTENTS_FILE = "$installer$/org/aspectj/resources/contents.txt";
+    private String htmlSrc;
+
+    public void setHtmlSrc(String v) { htmlSrc = v; }
+
+    private String resourcesSrc;
+
+    public void setResourcesSrc(String v) { resourcesSrc = v; }
+
+    private String mainclass;
+
+    public void setMainclass(String v) { mainclass = v; }
+
+    private File installerClassJar;
+
+    public void setInstallerclassjar(String v) { 
+        installerClassJar = project.resolveFile(v);
+    }
+
+    protected List contentsNames = new ArrayList();
+
+    protected long contentsBytes = 0;
+
+    protected void addToContents(File file, String vPath) {
+        contentsNames.add(vPath);
+        contentsBytes += file.length();
+    }
+
+    String[] getFiles(File baseDir) {
+        DirectoryScanner ds = new DirectoryScanner();
+        setBasedir(baseDir.getAbsolutePath());
+        ds.setBasedir(baseDir);
+        //ds.setIncludes(new String [] {pattern});
+        ds.scan();
+        return ds.getIncludedFiles();
+    }
+
+    protected Copy getCopyTask() {
+        Copy cd = (Copy)project.createTask("copy");
+        if (null == cd) {
+            log("project.createTask(\"copy\") failed - direct", project.MSG_VERBOSE);
+            cd = new Copy();
+            cd.setProject(getProject());
+        }
+        return cd;
+    }
+    protected void finishZipOutputStream(ZipOutputStream zOut) throws IOException, BuildException {
+        writeContents(zOut);
+        writeManifest(zOut);
+        File tmpDirF = File.createTempFile("tgz", ".di");
+        File tmpDir = new File(tmpDirF.getAbsolutePath() + "r");
+        tmpDirF.delete();
+        String tmp = tmpDir.getAbsolutePath();
+
+        // installer class files
+        Expand expand = new Expand();
+        expand.setProject(getProject());
+        expand.setSrc(installerClassJar);
+        expand.setDest(new File(tmp));
+        PatternSet patterns = new PatternSet();
+        patterns.setIncludes(INCLUDE_CLASSES);
+        expand.addPatternset(patterns);
+        expand.execute();        
+
+        // move the correct resource files into the jar
+        Copy cd = getCopyTask();
+        fileset = new FileSet();
+        fileset.setDir(new File(resourcesSrc));
+        fileset.setIncludes("*");
+        fileset.setExcludes("contents.txt,properties.txt");
+        cd.addFileset(fileset);
+        cd.setTodir(new File(tmp+"/$installer$/org/aspectj/resources"));
+        cd.execute();
+        project.addFilter("installer.main.class", this.mainclass);
+        Copy cf = getCopyTask();
+        fileset = new FileSet();
+        fileset.setDir(new File(resourcesSrc));
+        fileset.setIncludes("properties.txt");
+        cf.setFiltering(true);
+        cf.addFileset(fileset);
+        cf.setTodir(new File(tmp+"/$installer$/org/aspectj/resources"));
+        cf.execute();
+        // move the correct resource files into the jar
+        cd = getCopyTask();
+        fileset = new FileSet();
+        fileset.setDir(new File(htmlSrc));
+        fileset.setIncludes("*");
+        cd.addFileset(fileset);
+        cd.setTodir(new File(tmp+"/$installer$/org/aspectj/resources"));
+        cd.execute();
+        // now move these files into the jar
+        setBasedir(tmp);
+        writeFiles(zOut, getFiles(tmpDir));
+        // and delete the tmp dir
+        Delete dt = (Delete)project.createTask("delete");
+        if (null == dt) {
+            dt = new Delete();
+            dt.setProject(getProject());
+        }
+        dt.setDir(new File(tmp));
+        dt.execute();
+    }
+
+    static final char NEWLINE = '\n';
+
+    protected void writeContents(ZipOutputStream zOut) throws IOException {
+        // write to a StringBuffer
+        StringBuffer buf = new StringBuffer();
+        buf.append(contentsBytes);
+        buf.append(NEWLINE);
+        for (Iterator i = contentsNames.iterator(); i.hasNext(); ) {
+            String name = (String)i.next();
+            buf.append(name);
+            buf.append(NEWLINE);
+        }
+        zipFile(new StringBufferInputStream(buf.toString()), zOut, CONTENTS_FILE, System.currentTimeMillis());
+    }
+
+    protected void writeManifest(ZipOutputStream zOut) throws IOException {
+        // write to a StringBuffer
+        StringBuffer buf = new StringBuffer();
+        buf.append("Manifest-Version: 1.0");
+        buf.append(NEWLINE);
+        buf.append("Main-Class: " + MAIN_CLASS);
+        buf.append(NEWLINE);
+        zipFile(new StringBufferInputStream(buf.toString()), zOut, "META-INF/MANIFEST.MF", System.currentTimeMillis());
+    }
+
+    //XXX cut-and-paste from Zip super-class (under apache license)
+    private File zipFile;
+    private File baseDir;
+    private boolean doCompress = true;
+    protected String archiveType = "zip";
+
+    /**
+     * This is the name/location of where to
+     * create the .zip file.
+     */
+    public void setZipfile(String zipFilename) {
+        zipFile = project.resolveFile(zipFilename);
+    }
+
+    /**
+     * This is the base directory to look in for
+     * things to zip.
+     */
+    public void setBasedir(String baseDirname) {
+        baseDir = project.resolveFile(baseDirname);
+    }
+
+    /**
+     * Sets whether we want to compress the files or only store them.
+     */
+    public void setCompress(String compress) {
+        doCompress = Project.toBoolean(compress);
+    }
+
+    protected void initZipOutputStream(ZipOutputStream zOut)
+        throws IOException, BuildException
+    {
+    }
+
+    protected void zipDir(File dir, ZipOutputStream zOut, String vPath)
+        throws IOException
+    {
+    }
+
+    protected void zipFile(InputStream in, ZipOutputStream zOut, String vPath,
+                           long lastModified)
+        throws IOException
+    {
+        ZipEntry ze = new ZipEntry(vPath);
+        ze.setTime(lastModified);
+
+        /*
+         * XXX ZipOutputStream.putEntry expects the ZipEntry to know its
+         * size and the CRC sum before you start writing the data when using
+         * STORED mode.
+         *
+         * This forces us to process the data twice.
+         *
+         * I couldn't find any documentation on this, just found out by try
+         * and error.
+         */
+        if (!doCompress) {
+            long size = 0;
+            CRC32 cal = new CRC32();
+            if (!in.markSupported()) {
+                // Store data into a byte[]
+                ByteArrayOutputStream bos = new ByteArrayOutputStream();
+                byte[] buffer = new byte[8 * 1024];
+                int count = 0;
+                do {
+                    size += count;
+                    cal.update(buffer, 0, count);
+                    bos.write(buffer, 0, count);
+                    count = in.read(buffer, 0, buffer.length);
+                } while (count != -1);
+                in = new ByteArrayInputStream(bos.toByteArray());
+            } else {
+                in.mark(Integer.MAX_VALUE);
+                byte[] buffer = new byte[8 * 1024];
+                int count = 0;
+                do {
+                    size += count;
+                    cal.update(buffer, 0, count);
+                    count = in.read(buffer, 0, buffer.length);
+                } while (count != -1);
+                in.reset();
+            }
+            ze.setSize(size);
+            ze.setCrc(cal.getValue());
+        }
+        zOut.putNextEntry(ze);
+        byte[] buffer = new byte[8 * 1024];
+        int count = 0;
+        do {
+            zOut.write(buffer, 0, count);
+            count = in.read(buffer, 0, buffer.length);
+        } while (count != -1);
+    }
+
+    protected void zipFile(File file, ZipOutputStream zOut, String vPath)
+        throws IOException
+    {
+        if ( !vPath.startsWith("$installer$") ) {
+            addToContents(file, vPath);
+        }
+        FileInputStream fIn = new FileInputStream(file);
+        try {
+            zipFile(fIn, zOut, vPath, file.lastModified());
+        } finally {
+            fIn.close();
+        }
+    }
+
+    public void execute() throws BuildException {
+        if (installerClassJar == null) {
+            throw new BuildException("installerClassJar attribute must be set!");
+        }
+        if (!installerClassJar.canRead() 
+            || !installerClassJar.getPath().endsWith(".jar")) {
+            throw new BuildException("not readable jar:" + installerClassJar);
+        }
+//        if (installerClassDir == null) {
+//            throw new BuildException("installerClassDir attribute must be set!");
+//        }
+//        if (!installerClassDir.exists()) {
+//            throw new BuildException("no such directory: installerClassDir=" + installerClassDir);
+//        }
+        if (baseDir == null) {
+            throw new BuildException("basedir attribute must be set!");
+        }
+        if (!baseDir.exists()) {
+            throw new BuildException("basedir does not exist!");
+        }
+        DirectoryScanner ds = super.getDirectoryScanner(baseDir);
+        String[] files = ds.getIncludedFiles();
+        String[] dirs  = ds.getIncludedDirectories();
+        log("Building installer: "+ zipFile.getAbsolutePath());
+        ZipOutputStream zOut = null;
+        try {
+            zOut = new ZipOutputStream(new FileOutputStream(zipFile));
+            if (doCompress) {
+                zOut.setMethod(ZipOutputStream.DEFLATED);
+            } else {
+                zOut.setMethod(ZipOutputStream.STORED);
+            }
+            initZipOutputStream(zOut);
+            writeDirs(zOut, dirs);
+            writeFiles(zOut, files);
+            finishZipOutputStream(zOut);
+        } catch (IOException ioe) {
+            String msg = "Problem creating " + archiveType + " " + ioe.getMessage();
+            throw new BuildException(msg, ioe, location);
+        } finally {
+            if (zOut != null) {
+                try {
+                    // close up
+                    zOut.close();
+                }
+                catch (IOException e) {}
+            }
+        }
+    }
+
+    protected void writeDirs(ZipOutputStream zOut, String[] dirs) throws IOException {
+        for (int i = 0; i < dirs.length; i++) {
+            File f = new File(baseDir,dirs[i]);
+            String name = dirs[i].replace(File.separatorChar,'/')+"/";
+            zipDir(f, zOut, name);
+        }
+    }
+
+    protected void writeFiles(ZipOutputStream zOut, String[] files) throws IOException {
+        for (int i = 0; i < files.length; i++) {
+            File f = new File(baseDir,files[i]);
+            String name = files[i].replace(File.separatorChar,'/');
+            zipFile(f, zOut, name);
+        }
+    }
+
+}
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/AJPush.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/AJPush.java
new file mode 100644
index 000000000..4a778cb67
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/AJPush.java
@@ -0,0 +1,89 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.*;
+import org.apache.tools.ant.types.*;
+import org.apache.tools.ant.taskdefs.*;
+import java.io.*;
+import java.util.*;
+import java.text.DecimalFormat;
+
+public class AJPush extends ConditionalTask {
+    private File src;
+
+    public void setSrc(String v) { src = project.resolveFile(v); }
+
+    private String key;
+
+    public void setKey(String v) { key = v; }
+
+    File releaseDir = null;
+    File downloadDir = null;
+    boolean waiting = false;
+
+    public void execute() throws org.apache.tools.ant.BuildException {
+        //File releaseDir = src.getParentFile();
+        // todo: dependency on ant script variable name aj.release.dir
+        releaseDir = project.resolveFile(project.getProperty("aj.release.dir"));
+        // todo: dependency on ant script variable name download.dir
+        downloadDir = project.resolveFile(project.getProperty("download.dir"));
+        // For testing make sure these directories are made
+        Mkdir mkdir = (Mkdir) project.createTask("mkdir");
+        mkdir.setDir(releaseDir);
+        mkdir.execute();
+        mkdir = (Mkdir) project.createTask("mkdir");
+        mkdir.setDir(downloadDir);
+        mkdir.execute();
+        log("Pushing from " + releaseDir + " to " + downloadDir);
+        // add info to release.txt
+        try {
+            File releaseFile = new File(releaseDir, "release.txt");
+            File downloadFile = new File(downloadDir, "release.txt");
+            if (!releaseFile.canRead()) {
+                releaseFile.createNewFile();
+            }
+            addReleaseInfo(src, releaseFile);
+            // copy to staging web server
+            project.copyFile(src, new File(downloadDir, src.getName()));
+            project.copyFile(releaseFile, downloadFile);
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+    }
+
+    void addReleaseInfo(File file, File propFile) throws IOException {
+        Properties props = new Properties();
+        if (propFile.canRead()) {
+            props.load(new FileInputStream(propFile));
+        }
+        file.createNewFile(); // create new only if necessary
+        long bytes = file.length();
+        DecimalFormat df = new DecimalFormat();
+        df.setGroupingSize(3);
+        String bytesString = df.format(bytes);
+        props.put("release." + key + ".size.bytes", bytesString);
+        props.put("release." + key + ".date", project.getProperty("build.date"));
+        props.put("release." + key + ".filename", file.getName());
+        props.put("release.date", project.getProperty("build.date"));
+        props.put("release.version", project.getProperty("build.version.short"));
+        props.put("release.versionName", project.getProperty("build.version.long"));
+        String userName = System.getProperty("user.name");
+        if (userName != null) {
+            props.put("release." + key + ".username", userName);
+        }
+        props.store(new FileOutputStream(propFile), null);
+    }
+
+}
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/AntBuilder.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/AntBuilder.java
new file mode 100644
index 000000000..d4001161e
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/AntBuilder.java
@@ -0,0 +1,721 @@
+/* *******************************************************************
+ * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.Target;
+import org.apache.tools.ant.Task;
+import org.apache.tools.ant.taskdefs.Copy;
+import org.apache.tools.ant.taskdefs.Filter;
+import org.apache.tools.ant.taskdefs.Javac;
+import org.apache.tools.ant.taskdefs.Zip;
+import org.apache.tools.ant.types.FileSet;
+import org.apache.tools.ant.types.Path;
+import org.apache.tools.ant.types.ZipFileSet;
+import org.aspectj.internal.tools.build.BuildSpec;
+import org.aspectj.internal.tools.build.Builder;
+import org.aspectj.internal.tools.build.Messager;
+import org.aspectj.internal.tools.build.Module;
+import org.aspectj.internal.tools.build.Modules;
+import org.aspectj.internal.tools.build.ProductModule;
+import org.aspectj.internal.tools.build.Util;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * Implement Builder in Ant.
+ */
+public class AntBuilder extends Builder {
+    /*
+     * XXX This just constructs and uses Ant Task objects, 
+     * which in some cases causes the tasks to fail.
+     */
+
+    /** @return a Builder for this project and configuration */
+    public static Builder getBuilder(String config, Project project, File tempDir) {
+        boolean useEclipseCompiles = false;
+        boolean verbose = false;
+        if (null != config) {
+            if (-1 != config.indexOf("useEclipseCompiles")) {
+                useEclipseCompiles = true;
+            }
+            if (-1 != config.indexOf("verbose")) {
+                verbose = true;
+            }
+        }
+        Messager handler = new ProjectMessager(project);
+        Builder result = new ProductBuilder(project, tempDir, useEclipseCompiles, handler);
+        if (verbose) {
+            result.setVerbose(true);
+        }
+        return result;
+    }
+    
+    /** 
+     * Make and register target for this module and antecedants.
+     * This ensures that the (direct) depends list is generated
+     * for each target.
+     * This depends on topoSort to detect cycles. XXX unverified
+     */
+    private static void makeTargetsForModule(
+        final Module module, 
+        final Hashtable targets, 
+        final boolean rebuild) {
+        Target target = (Target) targets.get(module.name);
+        if (null == target) {
+            // first add the target
+            target = new Target();
+            target.setName(module.name);
+            List req = module.getRequired();
+            StringBuffer depends = new StringBuffer();
+            boolean first = true;
+            for (Iterator iterator = req.iterator(); iterator.hasNext();) {
+                Module reqModule = (Module) iterator.next();
+                if (rebuild || reqModule.outOfDate(false)) {
+                    if (!first) {
+                        depends.append(",");
+                    } else {
+                        first = false;
+                    }
+                    depends.append(reqModule.name);
+                }
+            }
+            if (0 < depends.length()) {
+                target.setDepends(depends.toString());
+            }
+            targets.put(module.name, target);
+
+            // then recursively add any required modules
+            for (Iterator iterator = module.getRequired().iterator();
+                iterator.hasNext();
+                ) {
+                Module reqModule = (Module) iterator.next();
+                if (rebuild || reqModule.outOfDate(false)) {
+                    makeTargetsForModule(reqModule, targets, rebuild);
+                }                
+            }                        
+        }
+    }
+
+    protected final Project project;
+
+    protected AntBuilder(Project project, File tempDir, boolean useEclipseCompiles,
+        Messager handler) {
+        super(tempDir, useEclipseCompiles, handler);
+        this.project = project;
+        Util.iaxIfNull(project, "project");
+    }
+    protected boolean copyFile(File fromFile, File toFile, boolean filter) {
+        Copy copy = makeCopyTask(filter);
+        copy.setFile(fromFile);
+        copy.setTofile(toFile);
+        executeTask(copy);
+        return true;
+    }
+    
+    protected void copyFileset(File toDir, FileSet fileSet, boolean filter) {
+        Copy copy = makeCopyTask(filter);
+        copy.addFileset(fileSet);
+        copy.setTodir(toDir);
+        executeTask(copy);
+    }
+
+    /** filter if FILTER_ON, use filters */
+    protected Copy makeCopyTask(boolean filter) {
+        Copy copy = new Copy();
+        copy.setProject(project);
+        if (FILTER_ON == filter) {
+            copy.setFiltering(true);
+            setupFilters(); 
+        }
+        return copy;
+    }
+    
+    /** lazily and manually generate properties */
+    protected Properties getFilterProperties() { // 
+        if (filterProps == null) {
+            long time = System.currentTimeMillis();
+            String version = null; // unknown - system?
+            filterProps = BuildSpec.getFilterProperties(time, version);
+        }
+        return filterProps;
+    }
+        
+    protected void setupFilters() {
+        if (!filterSetup) { // XXX check Ant - is this static?
+            Properties props = getFilterProperties();
+            for (Enumeration enum = props.keys(); enum.hasMoreElements();) {
+                String token = (String) enum.nextElement();
+                String value = props.getProperty(token);
+                Filter filter = new Filter();
+                filter.setProject(project);
+                filter.setToken(token);
+                filter.setValue(value);
+                if (!executeTask(filter)) {
+                    return;
+                }
+            }
+            filterSetup = true;
+        }
+    }
+    
+    protected boolean compile(Module module, File classesDir, List errors) {
+        // XXX  test whether build.compiler property takes effect automatically
+        // I suspect it requires the proper adapter setup.
+        Javac javac = new Javac();
+        javac.setProject(project);
+        
+        // -- source paths
+        Path path = new Path(project);
+        for (Iterator iter = module.getSrcDirs().iterator(); iter.hasNext();) {
+            File file = (File) iter.next();
+            path.createPathElement().setLocation(file);
+        }
+        javac.setSrcdir(path);
+        path = null;
+        
+        // -- classpath
+        Path classpath = new Path(project);
+        boolean hasLibraries = false;
+        // modules
+        for (Iterator iter = module.getRequired().iterator(); iter.hasNext();) {
+            Module required = (Module) iter.next();            
+            classpath.createPathElement().setLocation(required.getModuleJar());
+            if (!hasLibraries) {
+                hasLibraries = true;
+            }
+        }
+        // libraries
+        for (Iterator iter = module.getLibJars().iterator(); iter.hasNext();) {
+            File file = (File) iter.next();            
+            classpath.createPathElement().setLocation(file);
+            if (!hasLibraries) {
+                hasLibraries = true;
+            }
+        }
+        // need to add system classes??
+        boolean inEclipse = true; // XXX detect, fork only in eclipse
+        if (hasLibraries && inEclipse) {
+            javac.setFork(true); // XXX otherwise never releases library jars
+        }
+        
+        // -- set output directory
+        classpath.createPathElement().setLocation(classesDir);
+        javac.setClasspath(classpath);
+        javac.setDestdir(classesDir);
+        if (!classesDir.mkdirs()) {
+            errors.add("unable to create classes directory");
+            return false;
+        }
+        
+        // compile
+        try {
+            return executeTask(javac);
+        } catch (BuildException e) {
+            String args = "" + Arrays.asList(javac.getCurrentCompilerArgs());
+            errors.add("BuildException compiling " + module.toLongString() + args 
+                + ": " + Util.renderException(e));
+            return false;
+        } finally {
+            javac.init(); // be nice to let go of classpath libraries...
+        }
+    }
+    
+    /**
+     * Merge classes directory and any merge jars into module jar
+     * with any specified manifest file.  
+     * META-INF directories are excluded.
+     */
+    protected boolean assemble(Module module, File classesDir, List errors) {
+        if (!buildingEnabled) {
+            return false;
+        }
+        // ---- zip result up
+        Zip zip = new Zip();
+        zip.setProject(project);
+        zip.setDestFile(module.getModuleJar());
+        ZipFileSet zipfileset = null;
+        
+        // -- merge any resources in any of the src directories
+        for (Iterator iter = module.getSrcDirs().iterator(); iter.hasNext();) {
+            File srcDir = (File) iter.next();
+            zipfileset = new ZipFileSet();
+            zipfileset.setProject(project);
+            zipfileset.setDir(srcDir);
+            zipfileset.setIncludes(RESOURCE_PATTERN);
+            zip.addZipfileset(zipfileset);
+        }
+        
+        // -- merge any merge jars
+        List mergeJars =  module.getMerges();
+        final boolean useManifest = false;
+        if (0 < mergeJars.size()) {
+            for (Iterator iter = mergeJars.iterator(); iter.hasNext();) {
+                File mergeJar = (File) iter.next();
+                zipfileset = new ZipFileSet();
+                zipfileset.setProject(project);
+                zipfileset.setSrc(mergeJar);
+                zipfileset.setIncludes("**/*");
+                zipfileset.setExcludes("META-INF/*"); // XXXFileLiteral
+                zipfileset.setExcludes("meta-inf/*");
+                zip.addZipfileset(zipfileset);
+            }
+        }
+        // merge classes; put any meta-inf/manifest.mf here
+        File metaInfDir = new File(classesDir, "META-INF");
+        if (metaInfDir.canWrite()) {
+            Util.deleteContents(metaInfDir); // XXX only delete manifest
+        } 
+
+        // -- manifest
+        File manifest = new File(module.moduleDir, module.name + ".mf.txt");  // XXXFileLiteral
+        if (Util.canReadFile(manifest)) {
+            if (Util.canReadDir(metaInfDir) || metaInfDir.mkdirs()) {
+                copyFile(manifest, new File(metaInfDir, "manifest.mf"), FILTER_ON);  // XXXFileLiteral
+            } else {
+                errors.add("have manifest, but unable to create " + metaInfDir);
+                return false;
+            }
+        }        
+
+        zipfileset = new ZipFileSet();
+        zipfileset.setProject(project);
+        zipfileset.setDir(classesDir);
+        zipfileset.setIncludes("**/*");
+        zip.addZipfileset(zipfileset);
+
+        try {
+            handler.log("assembling " + module  + " in " + module.getModuleJar());
+            return executeTask(zip);
+        } catch (BuildException e) {
+            errors.add("BuildException zipping " + module + ": " + e.getMessage());
+            return false;
+        } finally {
+            module.clearOutOfDate();
+        }
+    }
+    /**
+	 * @see org.aspectj.internal.tools.build.Builder#buildAntecedants(Module)
+	 */
+	protected String[] getAntecedantModuleNames(Module module, boolean rebuild) {
+        Hashtable targets = new Hashtable();
+        makeTargetsForModule(module, targets, rebuild);   
+        // XXX bug: doc says topoSort returns String, but returns Target 
+        Collection result = project.topoSort(module.name, targets);
+        // XXX is it topoSort that should detect cycles?
+        int size = result.size();
+        if (0 == result.size()) {
+            return new String[0];
+        }
+        ArrayList toReturn = new ArrayList();
+        for (Iterator iter = result.iterator(); iter.hasNext();) {
+            Target target = (Target) iter.next();
+            String name = target.getName();
+            if (null == name) {
+                throw new Error("null name?");
+            } else {
+                toReturn.add(name);
+            }
+        }
+        // topoSort always returns module.name    
+        if ((1 == size) 
+            && module.name.equals(toReturn.get(0))
+            && !module.outOfDate(false)) {
+            return new String[0];
+        }
+        return (String[]) toReturn.toArray(new String[0]);
+    }
+        
+    /**
+     * Generate Module.assembledJar with merge of itself and all antecedants
+     */                    
+    protected boolean assembleAll(Module module, Messager handler) {
+        if (!buildingEnabled) {
+            return false;
+        }
+        Util.iaxIfNull(module, "module");
+        Util.iaxIfNull(handler, "handler");
+        if (module.outOfDate(false)) {
+            throw new IllegalStateException("module out of date: " + module);
+        }
+        
+        // ---- zip result up
+        Zip zip = new Zip();
+        zip.setProject(project);
+        zip.setDestFile(module.getAssembledJar());
+        ZipFileSet zipfileset = null;
+        
+        ArrayList known = module.findKnownJarAntecedants();
+        
+        // -- merge any antecedents, less any manifest
+        for (Iterator iter = known.iterator(); iter.hasNext();) {
+            File jarFile = (File) iter.next();
+            zipfileset = new ZipFileSet();
+            zipfileset.setProject(project);
+            zipfileset.setSrc(jarFile);
+            zipfileset.setIncludes("**/*");
+            zipfileset.setExcludes("META-INF/MANIFEST.MF");  // XXXFileLiteral
+            zipfileset.setExcludes("META-INF/manifest.mf");
+            zipfileset.setExcludes("meta-inf/manifest.mf");
+            zipfileset.setExcludes("meta-inf/MANIFEST.MF");
+            zip.addZipfileset(zipfileset);
+        }
+        
+        // merge the module jar itself, including same manifest (?)
+        zipfileset = new ZipFileSet();
+        zipfileset.setProject(project);
+        zipfileset.setSrc(module.getModuleJar());
+        zip.addZipfileset(zipfileset);
+
+        try {
+            handler.log("assembling all " + module  + " in " + module.getAssembledJar());
+            return executeTask(zip);
+        } catch (BuildException e) {
+            handler.logException("BuildException zipping " + module, e);
+            return false;
+        } finally {
+            module.clearOutOfDate();
+        }
+    }
+
+    /**
+	 * @see org.aspectj.internal.tools.ant.taskdefs.Builder#buildInstaller(BuildSpec, String)
+	 */
+	protected boolean buildInstaller(
+		BuildSpec buildSpec,
+		String targDirPath) {
+		return false;
+	}
+    
+    /**
+	 * @see org.aspectj.internal.tools.ant.taskdefs.Builder#copyFiles(File, File, String, String, boolean)
+	 */
+	protected boolean copyFiles(
+		File fromDir,
+		File toDir,
+		String includes,
+		String excludes,
+		boolean filter) {
+        Copy copy = makeCopyTask(filter);
+        copy.setTodir(toDir);
+        FileSet fileset = new FileSet();
+        fileset.setDir(fromDir);
+        if (null != includes) {
+            fileset.setIncludes(includes);
+        }
+        if (null != excludes) {
+            fileset.setExcludes(excludes);
+        }
+        copy.addFileset(fileset);
+        executeTask(copy);
+        
+		return false;
+	}
+    
+    /** task.execute() and any advice */
+    protected boolean executeTask(Task task) {
+        if (!buildingEnabled) {
+            return false;
+        }
+        task.execute();
+        return true;
+    }  
+
+}
+
+     
+// finally caught by failing to comply with proper ant initialization
+//  /**
+//   * Build a module that has a build script.
+//   * @param buildSpec the module to build
+//   * @param buildScript the script file
+//     * @throws BuildException if build fails
+//   */
+//  private void buildByScript(BuildSpec buildSpec, File buildScript) 
+//        throws BuildException {
+//      Ant ant = new Ant();
+//        ant.setProject(getProject());
+//        ant.setAntfile(buildScript.getAbsolutePath());
+//        ant.setDescription("building module " + buildSpec.module);
+//        ant.setDir(buildScript.getParentFile());
+//        ant.setInheritAll(true);
+//        ant.setInheritRefs(false);
+//        ant.setLocation(getLocation());
+//        ant.setOwningTarget(getOwningTarget());
+//        // by convention, for build.xml, use module name to publish
+//        ant.setTarget(buildSpec.module);
+//        ant.setTaskName("ant");
+//        loadAntProperties(ant, buildSpec);
+//        ant.execute();
+//     }
+//     
+//     /** override definitions */
+//     private void loadAntProperties(Ant ant, BuildSpec buildSpec) {
+//        Property property = ant.createProperty();
+//        property.setName(BuildSpec.baseDir_NAME);
+//        property.setFile(buildSpec.baseDir);
+//        property = ant.createProperty();
+//        property.setName(buildSpec.distDir_NAME);
+//        property.setFile(buildSpec.distDir);
+//        property = ant.createProperty();
+//        property.setName(BuildSpec.tempDir_NAME);
+//        property.setFile(buildSpec.tempDir);
+//        property = ant.createProperty();
+//        property.setName(BuildSpec.jarDir_NAME);
+//        property.setFile(buildSpec.jarDir);        
+//        property = ant.createProperty();
+//        property.setName(BuildSpec.stagingDir_NAME);
+//        property.setFile(buildSpec.stagingDir);        
+//    }
+
+
+/** 
+ * Segregate product-building API's from module-building APIs for clarity.
+ * These are called by the superclass if the BuildSpec warrants. 
+ * XXX extremely brittle/arbitrary assumptions.
+ * @see BuildModule for assumptions
+ */
+class ProductBuilder extends AntBuilder {
+
+    private static String getProductInstallResourcesSrc(BuildSpec buildSpec) {
+        final String resourcesName = "installer-resources";  // XXXFileLiteral
+        File dir = buildSpec.productDir.getParentFile();
+        String result = null;
+        if (null == dir) {
+            return "../../" + resourcesName;
+        } 
+        dir = dir.getParentFile();
+        if (null == dir) {
+            return "../" + resourcesName;
+        } else {
+            dir = new File(dir, resourcesName);
+            return dir.getPath();
+        }
+    }
+
+    private static String getProductInstallerFileName(BuildSpec buildSpec) {   // XXXFileLiteral
+        return "aspectj-" 
+            + buildSpec.productDir.getName()
+            + "-"
+            + Util.shortVersion(buildSpec.version)
+            + ".jar"; 
+    }
+    
+   /**
+     * Calculate name of main, typically InitialCap, and hence installer class.
+     * @return $$installer$$.org.aspectj." + ProductName + "Installer" 
+     */
+     
+    private static String getProductInstallerMainClass(BuildSpec buildSpec) {
+        String productName = buildSpec.productDir.getName();
+        String initial = productName.substring(0, 1).toUpperCase();
+        productName = initial + productName.substring(1);
+        return "$installer$.org.aspectj." + productName + "Installer";   // XXXNameLiteral
+    }
+    
+    /** @see Builder.getBuilder(String, Project, File) */
+    ProductBuilder(
+        Project project, 
+        File tempDir, 
+        boolean useEclipseCompiles,
+        Messager handler) {
+        super(project, tempDir, useEclipseCompiles, handler);
+    }
+    
+    /**
+     * Build product by discovering any modules to build,
+     * building those, assembling the product distribution,
+     * and optionally creating an installer for it.
+     * @return true on success
+     */
+    protected boolean buildProduct(BuildSpec buildSpec) 
+        throws BuildException {
+        Util.iaxIfNull(buildSpec, "buildSpec");
+        // XXX if installer and not out of date, do not rebuild unless rebuild set
+
+        if (!buildSpec.trimTesting) {
+            buildSpec.trimTesting = true;
+            handler.log("testing trimmed for " + buildSpec);
+        }
+        Util.iaxIfNotCanReadDir(buildSpec.productDir, "productDir");
+        Util.iaxIfNotCanReadDir(buildSpec.baseDir, "baseDir");
+        Util.iaxIfNotCanWriteDir(buildSpec.distDir, "distDir");
+
+        // ---- discover modules to build, and build them
+        Modules modules = new Modules(
+            buildSpec.baseDir, 
+            buildSpec.jarDir, 
+            buildSpec.trimTesting, 
+            handler);
+        ProductModule[] productModules = discoverModules(buildSpec.productDir, modules);
+        for (int i = 0; i < productModules.length; i++) {
+            if (buildSpec.verbose) {
+                handler.log("building product module " + productModules[i]); 
+            }
+            if (!buildProductModule(productModules[i])) {
+                return false;
+            }
+        }
+        if (buildSpec.verbose) {
+            handler.log("assembling product module for " + buildSpec); 
+        }
+        
+        // ---- assemble product distribution
+        final String productName = buildSpec.productDir.getName();
+        final File targDir = new File(buildSpec.distDir, productName);
+        final String targDirPath = targDir.getPath();
+        if (targDir.canWrite()) {
+            Util.deleteContents(targDir);
+        }
+        
+        if (!targDir.canWrite() && !targDir.mkdirs()) {
+            if (buildSpec.verbose) {
+                handler.log("unable to create " + targDir);
+            }
+            return false;
+        }
+        // filter-copy everything but the binaries
+        Copy copy = makeCopyTask(true);
+        copy.setTodir(targDir);
+        File distDir = new File(buildSpec.productDir, "dist");       // XXXFileLiteral
+        Util.iaxIfNotCanReadDir(distDir, "product dist directory");
+        FileSet fileset = new FileSet();
+        fileset.setDir(distDir);
+        fileset.setExcludes(Builder.BINARY_SOURCE_PATTERN);
+        copy.addFileset(fileset);
+        if (!executeTask(copy)) {
+            return false;
+        }
+        
+        // copy binaries (but not module flag files)
+        String excludes = null;
+        {
+            StringBuffer buf = new StringBuffer();        
+            for (int i = 0; i < productModules.length; i++) {
+                if (0 < buf.length()) {
+                    buf.append(",");
+                }
+                buf.append(productModules[i].relativePath);
+            }
+            if (0 < buf.length()) {
+                excludes = buf.toString();
+            }
+        }
+        copy = makeCopyTask(false);
+        copy.setTodir(targDir);
+        fileset = new FileSet();
+        fileset.setDir(distDir);
+        fileset.setIncludes(Builder.BINARY_SOURCE_PATTERN);
+        if (null != excludes) {
+            fileset.setExcludes(excludes);
+        }
+        copy.addFileset(fileset);
+        if (!executeTask(copy)) {
+            return false;
+        }
+
+        // copy binaries associated with module flag files
+        for (int i = 0; i < productModules.length; i++) {
+            ProductModule product = productModules[i];
+            String targPath = targDirPath + "/" + product.relativePath;
+            File jarFile = (product.assembleAll 
+                ? product.module.getAssembledJar()
+                : product.module.getModuleJar() );
+            copyFile(jarFile, new File(targPath), FILTER_OFF);
+        } 
+        handler.log("created product in " + targDir);
+        // ---- create installer 
+        if (buildSpec.createInstaller) {
+            return buildInstaller(buildSpec, targDirPath);
+        } else {
+            return true;
+        }
+    }
+    
+    protected boolean buildInstaller(BuildSpec buildSpec, String targDirPath) {
+        if (buildSpec.verbose) {
+            handler.log("creating installer for " + buildSpec);
+        }
+        AJInstaller installer = new AJInstaller();
+        installer.setProject(project);
+        installer.setBasedir(targDirPath);
+        //installer.setCompress();
+        File installSrcDir = new File(buildSpec.productDir, "install");   // XXXFileLiteral
+        Util.iaxIfNotCanReadDir(installSrcDir, "installSrcDir");            
+        installer.setHtmlSrc(installSrcDir.getPath());
+        String resourcePath = getProductInstallResourcesSrc(buildSpec);
+        File resourceSrcDir = new File(resourcePath);
+        Util.iaxIfNotCanReadDir(resourceSrcDir, "resourceSrcDir");                        
+        installer.setResourcesSrc(resourcePath);
+        String name = getProductInstallerFileName(buildSpec);
+        File outFile = new File(buildSpec.jarDir, name);
+        installer.setZipfile(outFile.getPath());
+        installer.setMainclass(getProductInstallerMainClass(buildSpec));
+        installer.setInstallerclassjar(getBuildJar(buildSpec));
+        return executeTask(installer);
+        
+        // -- test installer XXX
+        // create text setup file
+        // run installer with setup file
+        // cleanup installed product
+    }
+    
+    private String getBuildJar(BuildSpec buildSpec) {
+        return buildSpec.baseDir.getPath() 
+            + "/lib/build/build.jar" ; // XXX
+    }
+    
+    private Module moduleForReplaceFile(File replaceFile, Modules modules) {
+        String jarName = moduleAliasFor(replaceFile.getName().toLowerCase());
+        if (jarName.endsWith(".jar") || jarName.endsWith(".zip")) {   // XXXFileLiteral
+            jarName = jarName.substring(0, jarName.length()-4);
+        } else {
+            throw new IllegalArgumentException("can only replace .[jar|zip]");
+        }
+        boolean assembleAll = jarName.endsWith("-all");
+        String name = (!assembleAll ? jarName : jarName.substring(0, jarName.length()-4));
+        return modules.getModule(name);
+    }
+    
+}
+
+
+class ProjectMessager extends Messager {
+    private final Project project;
+    public ProjectMessager(Project project) {
+        Util.iaxIfNull(project, "project");
+        this.project = project;
+    }
+    
+    public boolean log(String s) {
+        project.log(s);
+        return true;
+    }
+    public boolean error(String s) {
+        project.log(s, project.MSG_ERR);
+        return true;
+    }
+    public boolean logException(String context, Throwable thrown) {
+        project.log(context + Util.renderException(thrown), project.MSG_ERR);
+        return true;
+    }
+
+}
\ No newline at end of file
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/BuildModule.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/BuildModule.java
new file mode 100644
index 000000000..a0f56f1d6
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/BuildModule.java
@@ -0,0 +1,156 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Location;
+import org.apache.tools.ant.Task;
+import org.apache.tools.ant.types.Path;
+import org.aspectj.internal.tools.build.BuildSpec;
+import org.aspectj.internal.tools.build.Builder;
+
+import java.io.File;
+
+/**
+ * Ant interface to build a product or module, including any required modules.
+ * @see Builder
+ */
+public class BuildModule extends Task { // quickie hack...
+
+    public static void main(String[] args) {
+        TestBuildModule.main(args);
+    }    
+
+    private static File pathToFile(Path path) {
+        if (null != path) {
+            String[] list = path.list();
+            if ((null == list) || (1 != list.length)) {
+                throw new IllegalArgumentException("expected exactly 1 element");
+            }
+            return new File(list[0]);
+        }
+        return null;
+    }
+    BuildSpec buildSpec;
+
+    public BuildModule() {
+        buildSpec = new BuildSpec();
+        buildSpec.version = BuildSpec.BUILD_VERSION_DEFAULT;
+    }
+    
+    public void setModuledir(Path moduleDir) {
+        buildSpec.moduleDir = pathToFile(moduleDir);
+    }
+    
+    public void setModule(String module) { // XXX handle multiple modules, same builder
+        buildSpec.module = module;
+    }
+    
+    public void setVersion(String version) {
+        buildSpec.version = version;
+    }
+    public void setBasedir(Path baseDir) {
+        buildSpec.baseDir = pathToFile(baseDir);
+    }
+    
+    public void setJardir(Path jarDir) {
+        buildSpec.jarDir = pathToFile(jarDir);
+    }
+    
+    public void setTrimtesting(boolean trimTesting) {
+        buildSpec.trimTesting = trimTesting;
+    }
+    
+    public void setAssembleall(boolean assembleAll) {
+        buildSpec.assembleAll = assembleAll;
+    }
+    
+    public void setRebuild(boolean rebuild) {    
+        buildSpec.rebuild = rebuild;
+    }
+    
+    public void setFailonerror(boolean failonerror) {    
+        buildSpec.failonerror = failonerror;
+    }
+    
+    public void setCreateinstaller(boolean create) {    
+        buildSpec.createInstaller = create;
+    }
+    
+    public void setVerbose(boolean verbose) {    
+        buildSpec.verbose = verbose;
+    }
+
+    public void setBuildConfig(String buildConfig) {
+        buildSpec.buildConfig = buildConfig;
+    }
+
+    // --------------------------------------------------------- product build
+    
+    public void setProductdir(Path productDir) {
+        buildSpec.productDir = pathToFile(productDir);
+    }
+    
+    public void setTempdir(Path tempDir) {
+        buildSpec.tempDir = pathToFile(tempDir);
+    }
+    
+    public void setDistdir(Path distdir) {
+        buildSpec.distDir = pathToFile(distdir);
+    }
+        
+    public void execute() throws BuildException {
+        final BuildSpec buildSpec = this.buildSpec;
+        this.buildSpec = new BuildSpec();
+        build(buildSpec);    
+    }
+    
+    private void build(BuildSpec buildSpec) throws BuildException {
+        final boolean failonerror = buildSpec.failonerror;
+        Builder builder = null;
+        try  {
+            File buildScript = new File(buildSpec.moduleDir, "build.xml");  // XXXFileLiteral
+            if (buildScript.canRead()) {
+                if (!buildByScript(buildSpec, buildScript)) {
+                    log("unable to build " + buildSpec + " using script: " + buildScript);
+                }
+            } else {
+                builder = AntBuilder.getBuilder(
+                    buildSpec.buildConfig, 
+                    getProject(), 
+                    buildSpec.tempDir);
+                if (!builder.build(buildSpec) && failonerror) {
+                    Location loc = getLocation();
+                    throw new BuildException("error building " + buildSpec, loc);
+                }
+            }
+        } catch (BuildException e) {
+            throw e;
+        } catch (Throwable t) {
+            Location loc = getLocation();
+            throw new BuildException("error building " + buildSpec, t, loc);
+        } finally {
+            if (null != builder) {
+                builder.cleanup();
+            }
+        }
+    }
+
+    boolean buildByScript(BuildSpec buildSpec, File buildScript) 
+        throws BuildException {
+        return false;
+    }
+}
+ 
\ No newline at end of file
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java
new file mode 100644
index 000000000..d79c9774f
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java
@@ -0,0 +1,735 @@
+/* *******************************************************************
+ * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.*;
+import org.apache.tools.ant.types.*;
+import org.apache.tools.ant.taskdefs.*;
+import java.io.*;
+import java.util.*;
+
+/** 
+ * Check that included .java files contain license and copyright strings
+ * for MPL 1.0 (default), Apache, or CPL.
+ * Use list="true" to get a list of known license variants {license}-{copyrightHolder}
+ * todo reimplement with regexp and jdiff FileLine utilities 
+ */
+public class Checklics extends MatchingTask {
+	/*
+	  This does not enforce that copyrights are correct/current,
+	  only that they exist.
+	  E.g., the default behavior requires MPL but permits either 
+	  Xerox or PARC copyright holders and any valid year.
+	 */
+    public static final String MPL_TAG = "mpl";
+    public static final String APACHE_TAG = "apache";
+    public static final String CPL_IBM_PARC_TAG = "cpl-ibm|parc";
+    public static final String CPL_IBM_TAG = "cpl-ibm";
+    public static final String MPL_XEROX_PARC_TAG = "mpl-parc|xerox";
+    public static final String MPL_ONLY_TAG = "mpl-only";
+    public static final String MPL_PARC_TAG = "mpl-parc";
+    public static final String PARC_COPYRIGHT_TAG = "parc-copy";
+    public static final String CPL_IBM_PARC_XEROX_TAG = "cpl-ibm|parc|xerox";
+    public static final String DEFAULT = CPL_IBM_PARC_XEROX_TAG;
+    
+    static final Hashtable LICENSES; // XXX unmodifiable Map
+    
+	static {
+		final String XEROX = "Xerox";
+		final String PARC = "Palo Alto Research Center";
+		final String APACHE = "The Apache Software Foundation";
+		final String IBM = "IBM";
+		final String IBM_LONG = "International Business Machines";
+		final String LIC_APL =
+			"Apache Software Foundation (http://www.apache.org/)";
+		// XXX
+		final String LIC_MPL = "http://aspectj.org/MPL/";
+		//final String LIC_CPL    = "http://www.eclipse.org/legal/cpl-v"; // XXX not versioned
+		final String LIC_CPL = "Common Public License";
+		// XXX not versioned
+		License APL = new License(APACHE_TAG, LIC_APL, APACHE);
+		License MPL = new License(MPL_TAG, LIC_MPL, XEROX);
+		License MPL_XEROX_PARC = new License(DEFAULT, LIC_MPL, XEROX, PARC);
+		License CPL_IBM_PARC = new License(CPL_IBM_PARC_TAG,LIC_CPL,
+				                    new String[] { IBM_LONG, IBM, PARC });
+        License CPL_IBM_PARC_XEROX = new License(CPL_IBM_PARC_XEROX_TAG,LIC_CPL,
+                                    new String[] { IBM_LONG, IBM, PARC, XEROX });
+        License CPL_IBM = new License(CPL_IBM_TAG, LIC_CPL, IBM, IBM_LONG);
+        License MPL_ONLY = new License(MPL_ONLY_TAG, LIC_MPL);
+        License MPL_PARC = new License(MPL_PARC_TAG, LIC_MPL, PARC);
+		License PARC_COPYRIGHT = new License(PARC_COPYRIGHT_TAG, null, PARC);
+		LICENSES = new Hashtable();
+		LICENSES.put(APL.tag, APL);
+		LICENSES.put(MPL.tag, MPL);
+		LICENSES.put(MPL_PARC.tag, MPL_PARC);
+		LICENSES.put(MPL_XEROX_PARC.tag, MPL_XEROX_PARC);
+		LICENSES.put(CPL_IBM_PARC.tag, CPL_IBM_PARC);
+		LICENSES.put(MPL_ONLY.tag, MPL_ONLY);
+		LICENSES.put(CPL_IBM.tag, CPL_IBM);
+		LICENSES.put(PARC_COPYRIGHT.tag, PARC_COPYRIGHT);
+        LICENSES.put(CPL_IBM_PARC_XEROX.tag, CPL_IBM_PARC_XEROX);
+	}
+    
+    /** @param args String[] { &lt; sourcepath &gt; {, &lt; licenseTag &gt; } } */
+    public static void main(String[] args) {
+        switch (args.length) {
+            case 1 :  runDirect(args[0], null);
+                break;
+            case 2 :  runDirect(args[0], args[1]);
+                break;
+            default:
+                String options = "{replace-headers|get-years|list|{licenseTag}}";
+                System.err.println("java {me} sourcepath " + options);
+                break;
+        }
+    }
+
+    /**
+     * Run the license check directly
+     * @param sourcepaths String[] of paths to source directories
+     * @param license the String tag for the license, if any
+     * @throws IllegalArgumentException if sourcepaths is empty
+     * @return total number of failed licenses
+     */
+    public static int runDirect(String sourcepath, String license) {
+        if ((null == sourcepath) || (1 > sourcepath.length())) {
+            throw new IllegalArgumentException("bad sourcepath: " + sourcepath);
+        }
+        Checklics me = new Checklics();
+        Project p = new Project();
+        p.setName("direct interface to Checklics");
+        p.setBasedir(".");
+        me.setProject(p);
+        me.setSourcepath(new Path(p, sourcepath));
+        if (null != license) {
+            if ("replace-headers".equals(license)) {
+                me.setReplaceheaders(true);
+            } else if ("get-years".equals(license)) {
+                me.setGetYears(true);
+            } else if ("list".equals(license)) {
+                me.setList(true);
+            } else {
+                me.setLicense(license);        
+            }
+        }
+        me.execute();
+        return me.failed;
+    }
+	
+    private Path sourcepath;
+    private License license;
+    private boolean list;
+    private String streamTag;
+    private boolean failOnError;
+    private boolean getYears;
+    private boolean replaceHeaders;
+    private int passed;
+    private int failed;
+
+	private boolean printDirectories;
+
+    /** @param list if true, don't run but list known license tags */
+	public void setList(boolean list) {
+		this.list = list;
+	}
+    
+    public void setPrintDirectories(boolean print) {
+        printDirectories = print;
+    }
+    
+	/** 
+	 * When failOnError is true, if any file failed, throw BuildException 
+	 * listing number of files that file failed to pass license check 
+	 * @param fail if true, report errors by throwing BuildException  
+	 */
+	public void setFailOnError(boolean fail) {
+		this.failOnError = fail;
+	}
+
+	/** @param tl mpl | apache | cpl */
+	public void setLicense(String tl) {
+		License input = (License) LICENSES.get(tl);
+		if (null == input) {
+			throw new BuildException("no license known for " + tl);
+		}
+		license = input;
+	}
+
+	public void setSourcepath(Path path) {
+		if (sourcepath == null) {
+			sourcepath = path;
+		} else {
+			sourcepath.append(path);
+		}
+	}
+
+	public Path createSourcepath() {
+		return sourcepath == null
+			? (sourcepath = new Path(project))
+			: sourcepath.createPath();
+	}
+
+	public void setSourcepathRef(Reference id) {
+		createSourcepath().setRefid(id);
+	}
+
+	/** @param out "out" or "err" */
+	public void setOutputStream(String out) {
+		this.streamTag = out;
+	}
+    
+    public void setReplaceheaders(boolean replaceHeaders) {
+        this.replaceHeaders = replaceHeaders;
+    }
+    
+    public void setGetYears(boolean getYears) {
+        this.getYears = getYears;
+    }
+
+    /** list known licenses or check source tree */
+    public void execute() throws BuildException {
+        if (list) {
+            list();
+        } else if (replaceHeaders) {
+            replaceHeaders();
+        } else if (getYears) {
+            getYears();
+        } else {
+            checkLicenses();
+        }
+    }
+    
+    private PrintStream getOut() {
+        return ("err".equals(streamTag) ? System.err : System.out);
+    }
+
+    interface FileVisitor {
+        void visit(File file);
+    }
+    
+    /** visit all .java files in all directories... */
+    private void visitAll(FileVisitor visitor) {
+        List filelist = new ArrayList();
+        String[] dirs = sourcepath.list();
+        for (int i = 0; i < dirs.length; i++) {
+            File dir = project.resolveFile(dirs[i]);
+            String[] files = getDirectoryScanner(dir).getIncludedFiles();
+            for (int j = 0; j < files.length; j++) {
+                File file = new File(dir, files[j]);
+                String path = file.getPath();
+                if (path.endsWith(".java")) {
+                    visitor.visit(file);
+                }
+            }
+        }
+    }
+    
+    private void replaceHeaders() {
+        class YearVisitor implements FileVisitor {
+            public void visit(File file) {
+                HeaderInfo info = Header.checkFile(file);
+                if (!Header.replaceHeader(file, info)) {
+                    throw new BuildException("failed to replace header for " + file
+                        + " using " + info);
+                }
+            }
+        }
+        visitAll(new YearVisitor());
+    }
+
+    private void getYears() {
+        final PrintStream out = getOut();
+        class YearVisitor implements FileVisitor {
+            public void visit(File file) {
+                HeaderInfo info = Header.checkFile(file);
+                out.println(info.toString());                
+            }
+        }
+        visitAll(new YearVisitor());
+    }
+
+    private void checkLicenses() throws BuildException {
+        if (null == license) {
+            setLicense(DEFAULT);
+        }
+        final License license = this.license; // being paranoid...
+        if (null == license) {
+            throw new BuildException("no license");
+        }
+        final PrintStream out = getOut();
+
+        class Visitor implements FileVisitor {
+            int failed = 0;
+            int passed = 0;
+			public void visit(File file) {
+                if (license.checkFile(file)) {
+                    passed++;
+                } else {
+                    failed++;
+                    String path = file.getPath();
+                    if (!license.foundLicense()) {
+                        out.println(
+                            license.tag + "   LICENSE FAIL: " + path);
+                    }
+                    if (!license.foundCopyright()) {
+                        out.println(
+                            license.tag + " COPYRIGHT FAIL: " + path);
+                    }
+                }
+			}
+        }
+        Visitor visitor = new Visitor();
+        visitAll(visitor);
+        getOut().println(
+            "Total passed: "
+                + visitor.passed
+                + (visitor.failed == 0 ? "" : " failed: " + visitor.failed));
+        if (failOnError && (0 < visitor.failed)) {
+            throw new BuildException(
+                failed + " files failed license check");
+        }
+    }
+    
+    private void oldrun() throws BuildException {
+    	if (list) {
+			list();
+			return;
+		}
+		if (null == license) {
+			setLicense(DEFAULT);
+		}
+		final License license = this.license; // being paranoid...
+		if (null == license) {
+			throw new BuildException("no license");
+		}
+		final PrintStream out = getOut();
+
+		List filelist = new ArrayList();
+		String[] dirs = sourcepath.list();
+        failed = 0;
+        passed = 0;
+		for (int i = 0; i < dirs.length; i++) {
+			int dirFailed = 0;
+			int dirPassed = 0;
+			File dir = project.resolveFile(dirs[i]);
+			String[] files = getDirectoryScanner(dir).getIncludedFiles();
+			for (int j = 0; j < files.length; j++) {
+				File file = new File(dir, files[j]);
+				String path = file.getPath();
+				if (path.endsWith(".java")) {
+					if (license.checkFile(file)) {
+                        dirPassed++;
+                    } else {
+						dirFailed++;
+						if (!license.foundLicense()) {
+							out.println(
+								license.tag + "   LICENSE FAIL: " + path);
+						}
+						if (!license.foundCopyright()) {
+							out.println(
+								license.tag + " COPYRIGHT FAIL: " + path);
+						}
+					}
+				}
+			}
+            if (printDirectories) {
+    			out.println(
+    				"dir: "
+    					+ dirs[i]
+    					+ " passed: "
+    					+ dirPassed
+    					+ (dirFailed == 0 ? "" : " failed: " + dirFailed));
+            }
+			failed += dirFailed;
+			passed += dirPassed;
+		}
+	}
+
+	private void list() {
+		Enumeration enum = LICENSES.keys();
+		StringBuffer sb = new StringBuffer();
+		sb.append("known license keys:");
+		boolean first = true;
+		while (enum.hasMoreElements()) {
+			sb.append((first ? " " : ", ") + enum.nextElement());
+			if (first) {
+				first = false;
+			}
+		}
+		getOut().println(sb.toString());
+	}
+
+
+	/**
+	 * Encapsulate license and copyright specifications 
+	 * to check files use hokey string matching.
+	 */
+	public static class License {
+		/** acceptable years for copyright prefix to company - append " " */
+		static final String[] YEARS = // XXX remove older after license xfer?
+			new String[] { "2002 ", "2003 ", "2001 ", "2000 ", "1999 " }; 
+		public final String tag;
+		public final String license;
+		private final String[] copyright;
+		private boolean gotLicense;
+		private boolean gotCopyright;
+
+		License(String tag, String license) {
+			this(tag, license, (String[]) null);
+		}
+
+		License(String tag, String license, String copyright) {
+			this(tag, license, new String[] { copyright });
+		}
+
+		License(
+			String tag,
+			String license,
+			String copyright,
+			String altCopyright) {
+			this(tag, license, new String[] { copyright, altCopyright });
+		}
+
+		License(String tag, String license, String[] copyright) {
+			this.tag = tag;
+			if ((null == tag) || (0 == tag.length())) {
+				throw new IllegalArgumentException("null tag");
+			}
+			this.license = license;
+			this.copyright = copyright;
+		}
+
+		public final boolean gotValidFile() {
+			return foundLicense() && foundCopyright();
+		}
+
+		/** @return true if no license sought or if some license found */
+		public final boolean foundLicense() {
+			return ((null == license) || gotLicense);
+		}
+
+		/** @return true if no copyright sought or if some copyright found */
+		public final boolean foundCopyright() {
+			return ((null == copyright) || gotCopyright);
+		}
+
+		public boolean checkFile(final File file) {
+			clear();
+			boolean result = false;
+			BufferedReader input = null;
+			int lineNum = 0;
+			try {
+				input = new BufferedReader(new FileReader(file));
+				String line;
+				while (!gotValidFile()
+					&& (line = input.readLine()) != null) {
+					lineNum++;
+					checkLine(line);
+				}
+			} catch (IOException e) {
+				System.err.println(
+					"reading line " + lineNum + " of " + file);
+				e.printStackTrace(System.err);
+			} finally {
+				if (null != input) {
+					try {
+						input.close();
+					} catch (IOException e) {
+					} // ignore
+				}
+			}
+			return gotValidFile();
+		}
+
+		public String toString() {
+			return tag;
+		}
+
+		private void checkLine(String line) {
+			if ((null == line) || (0 == line.length())) {
+				return;
+			}
+			if (!gotLicense
+				&& (null != license)
+				&& (-1 != line.indexOf(license))) {
+				gotLicense = true;
+			}
+			if (!gotCopyright && (null != copyright)) {
+				int loc;
+				for (int j = 0;
+					!gotCopyright && (j < YEARS.length);
+					j++) {
+					if (-1 != (loc = line.indexOf(YEARS[j]))) {
+						loc += YEARS[j].length();
+						String afterLoc = line.substring(loc).trim();
+                        for (int i = 0;
+							!gotCopyright && (i < copyright.length);
+							i++) {
+							if (0 == afterLoc.indexOf(copyright[i])) {
+								gotCopyright = true;
+							}
+						}
+					}
+				}
+			}
+		}
+
+		private void clear() {
+			if (gotLicense) {
+				gotLicense = false;
+			}
+			if (gotCopyright) {
+				gotCopyright = false;
+			}
+		}
+	} // class License
+}
+
+class HeaderInfo {
+    /** File for which this is the info */
+    public final File file;
+    
+    /** unmodifiable List of String years */
+    public final List years;
+    
+    /** last line of license */
+    public final int lastLine;
+    
+    /** last line of license */
+    public final boolean hasLicense;
+
+    public HeaderInfo(File file, int lastLine, List years, boolean hasLicense) {
+        this.lastLine = lastLine;
+        this.file = file;
+        this.hasLicense = hasLicense;
+        List newYears = new ArrayList();
+        newYears.addAll(years);
+        Collections.sort(newYears);
+        this.years = Collections.unmodifiableList(newYears);
+        if ((null == file) || !file.canWrite()) {
+            throw new IllegalArgumentException("bad file: " + this);
+        }
+        if (!hasLicense) {
+            if ((0> lastLine) || (65 < lastLine)) {
+                throw new IllegalArgumentException("bad last line: " + this);
+            }
+        } else {            
+            if ((null == years) || (1 > years.size())) {
+                throw new IllegalArgumentException("no years: " + this);
+            }
+            if ((20 > lastLine) || (65 < lastLine)) {
+                throw new IllegalArgumentException("bad last line: " + this);
+            }
+        }
+    }
+
+    public String toString() {
+        return file.getPath() + ":" + lastLine  + " " + years;
+    }
+
+    public void writeHeader(PrintWriter writer) {
+        if (!hasLicense) {
+            writer.println(TOP);
+            writer.println(PARC_ONLY);
+            writeRest(writer);
+        } else {
+            final int size = years.size(); 
+            if (1 > size) {
+                throw new Error("no years found in " + toString());
+            }
+            String first = (String) years.get(0);
+            String last = (String) years.get(size-1);
+            boolean lastIs2002 = "2002".equals(last);
+            String xlast = last;
+            if (lastIs2002) {  // 2002 was PARC
+                xlast = (String) (size > 1 ? years.get(size-2) : null);
+                // 1999-2002 Xerox implies 1999-2001 Xerox
+                if (first.equals(xlast) && !"2001".equals(xlast)) {
+                    xlast = "2001";
+                }
+            }
+            String xyears = first + "-" + xlast;
+            if (first.equals(last)) {
+                xyears = first;
+            }
+    
+            writer.println(TOP);
+            if (!lastIs2002) {       // Xerox only
+                writer.println(XEROX_PREFIX + xyears + XEROX_SUFFIX + ". ");
+            } else if (size == 1) {    // PARC only
+                writer.println(PARC_ONLY);
+            } else {                   // XEROX plus PARC 
+                writer.println(XEROX_PREFIX + xyears + XEROX_SUFFIX + ", ");
+                writer.println(PARC);
+            }
+            writeRest(writer);
+        }
+    }
+    
+    void writeRest(PrintWriter writer) {
+        writer.println(" * All rights reserved. ");
+        writer.println(" * This program and the accompanying materials are made available ");
+        writer.println(" * under the terms of the Common Public License v1.0 ");
+        writer.println(" * which accompanies this distribution and is available at ");
+        writer.println(" * http://www.eclipse.org/legal/cpl-v10.html ");
+        writer.println(" *  ");
+        writer.println(" * Contributors: ");
+        writer.println(" *     Xerox/PARC     initial implementation ");
+        writer.println(" * ******************************************************************/");
+        writer.println("");
+    }
+    
+    public static final String TOP
+        = "/* *******************************************************************";
+    public static final String PARC
+        = " *               2002 Palo Alto Research Center, Incorporated (PARC).";
+    public static final String PARC_ONLY
+        = " * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).";
+    public static final String XEROX_PREFIX
+        = " * Copyright (c) ";
+    public static final String XEROX_SUFFIX
+        = " Xerox Corporation";
+    /*
+/* *******************************************************************
+ * Copyright (c) 1998-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ * Contributors:
+ *     Xerox/PARC     initial implementation
+ * ******************************************************************
+     
+     */
+}
+
+/**
+ * header search/replace using hokey string matching
+ */
+class Header {
+    
+    /** replace the header in file */
+    public static boolean replaceHeader(File file, HeaderInfo info) {
+        ArrayList years = new ArrayList();
+        int endLine = 0;
+        BufferedReader input = null;
+        PrintWriter output = null;
+        FileWriter outWriter = null;
+        int lineNum = 0;
+        boolean result = false;
+        final File inFile = new File(file.getPath() + ".tmp");
+        try {
+            File outFile = new File(file.getPath());
+            if (!file.renameTo(inFile) || !inFile.canRead()) {
+                throw new Error("unable to rename " + file + " to " + inFile);
+            }
+            outWriter = new FileWriter(outFile);
+            input = new BufferedReader(new FileReader(inFile));
+            output = new PrintWriter(outWriter, true);
+            info.writeHeader(output);
+            String line;
+            while (null != (line = input.readLine())) {
+                lineNum++;
+                if (lineNum > info.lastLine) {
+                    output.println(line);
+                }
+            }
+        } catch (IOException e) {
+            System.err.println(
+                "writing line " + lineNum + " of " + file);
+            e.printStackTrace(System.err);
+            result = false;
+        } finally {
+            if (null != input) {
+                try {
+                    input.close();
+                } catch (IOException e) {
+                    result = false;
+                } 
+            }
+            if (null != outWriter) {
+                try {
+                    outWriter.close();
+                } catch (IOException e) {
+                    result = false;
+                } 
+            }
+            result = inFile.delete();
+        }
+        return result;
+    }
+    
+    public static HeaderInfo checkFile(final File file) {
+        ArrayList years = new ArrayList();
+        int endLine = 0;
+        BufferedReader input = null;
+        int lineNum = 0;
+        try {
+            input = new BufferedReader(new FileReader(file));
+            String line;
+            while (null != (line = input.readLine())) {
+                lineNum++;
+                String ll = line.trim();
+                if (ll.startsWith("package ")
+                    || ll.startsWith("import ")) {
+                    break;  // ignore default package w/o imports
+                }
+                if (checkLine(line, years)) {
+                    endLine = lineNum;
+                    break;
+                }                    
+            }
+        } catch (IOException e) {
+            System.err.println(
+                "reading line " + lineNum + " of " + file);
+            e.printStackTrace(System.err);
+        } finally {
+            if (null != input) {
+                try {
+                    input.close();
+                } catch (IOException e) {
+                } // ignore
+            }
+        }
+        return new HeaderInfo(file, endLine, years, endLine > 0);
+    }
+
+    /**
+     * Add any years found (as String) to years,
+     * and return true at the first end-of-comment
+     * @return true if this line has end-of-comment
+     */
+    private static boolean checkLine(String line, ArrayList years) {
+        if ((null == line) || (0 == line.length())) {
+            return false;
+        }
+        int loc;
+        int start = 0;
+        
+        while ((-1 != (loc = line.indexOf("199", start))
+                || (-1 != (loc = line.indexOf("200", start))))) {
+            char c = line.charAt(loc + 3);
+            if ((c <= '9') && (c >= '0')) {
+                years.add(line.substring(loc, loc+4));
+            }
+            start = loc + 4;
+        }
+        
+        return (-1 != line.indexOf("*/"));
+    }
+
+} // class Header
+
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/ConditionalTask.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/ConditionalTask.java
new file mode 100644
index 000000000..8b5184121
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/ConditionalTask.java
@@ -0,0 +1,182 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.*;
+import java.util.*;
+
+public abstract class ConditionalTask extends Task {
+
+    public final static String TRUE = "true";
+
+    private   List ifs;
+    protected List ifs() {
+        return ifs != null ? ifs : (ifs = new Vector());
+    }
+
+    public If createIf() {
+        If i = new If();
+        ifs().add(i);
+        return i;
+    }
+
+    public If createIf(String name, String equals, boolean strict) {
+        If i = createIf();
+        i.setName(name);
+        i.setEquals(equals);
+        i.setStrict(strict);
+        return i;
+    }
+
+    public If createIf(String name, String equals) {
+        return createIf(name, equals, false);
+    }
+
+    public If createIf(String name) {
+        return createIf(name, TRUE, false);
+    }
+
+    public If createIf(String name, boolean strict) {
+        return createIf(name, TRUE, strict);
+    }
+
+    public void setIfs(String ifs) {
+        StringTokenizer tok = new StringTokenizer(ifs, ",;: ", false);
+        while (tok.hasMoreTokens()) {
+            String next = tok.nextToken();
+            int iequals = next.lastIndexOf("=");
+            String equals;
+            String name;
+            boolean strict;
+            If i = createIf();
+            if (iequals != -1) {
+                name   = next.substring(0, iequals);
+                equals = next.substring(iequals + 1);
+                strict = true;
+            } else {
+                name   = next.substring(0);
+                equals = TRUE;
+                strict = false;
+            }
+            i.setName(name);
+            i.setEquals(equals);
+            i.setStrict(strict);
+        }
+    }
+
+    public void setIf(String ifStr) {
+        setIfs(ifStr);
+    }
+
+    public class If {
+        public If() {
+            this(null, null);
+        }
+        public If(String name) {
+            this(name, TRUE);
+        }
+        public If(String name, String equals) {
+            setName(name);
+            setEquals(equals);
+        }
+        private String name;
+        public void setName(String name) {
+            this.name = name;
+        }
+        public String getName() {
+            return name;
+        }
+        private String equals;
+        public void setEquals(String equals) {
+            this.equals = equals;
+        }
+        public String getEquals() {
+            return equals;
+        }
+        private boolean strict = false;
+        public void setStrict(boolean strict) {
+            this.strict = strict;
+        }
+        public boolean isStrict() {
+            return strict;
+        }
+        public boolean isOk(String prop) {
+            return isOk(prop, isStrict());
+        }
+        //XXX Need a better boolean parser
+        public boolean isOk(String prop, boolean isStrict) {
+            if (isStrict) {
+                return prop != null && prop.equals(getEquals());
+            } else {
+                if (isOk(prop, true)) {
+                    return true;
+                }
+                if (prop == null || isFalse(getEquals())) {
+                    return true;
+                }
+                if ( (isTrue(getEquals()) && isTrue(prop)) ||
+                     (isFalse(getEquals()) && isFalse(prop)) ) {
+                    return true;
+                }
+                return false;
+            }
+        }
+        private boolean isFalse(String prop) {
+            return isOneOf(prop, falses) || isOneOf(prop, complement(trues));
+        }
+        private boolean isTrue(String prop) {
+            return isOneOf(prop, trues) || isOneOf(prop, complement(falses));
+        }
+        private boolean isOneOf(String prop, String[] strings) {
+            for (int i = 0; i < strings.length; i++) {
+                if (strings[i].equals(prop)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        private String[] complement(String[] strings) {
+            for (int i = 0; i < strings.length; i++) {
+                strings[i] = "!" + strings[i];
+            }
+            return strings;
+        }
+    }
+
+    final static String[] falses = { "false", "no"  };
+    final static String[] trues  = { "true",  "yes" };
+
+    protected boolean checkIfs() {
+        return getFalses().size() == 0;
+    }
+
+    protected List getFalses() {
+        Iterator iter = ifs().iterator();
+        List result = new Vector();
+        while (iter.hasNext()) {
+            If next = (If) iter.next();
+            String name = next.getName();
+            String prop = project.getProperty(name);
+            if (prop == null) {
+                prop = project.getUserProperty(name);
+            }
+            if (!next.isOk(prop)) {
+                result.add(name);
+            }
+        }
+        return result;
+    }
+
+    public abstract void execute() throws BuildException;
+}
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/CopyAndInlineStylesheet.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/CopyAndInlineStylesheet.java
new file mode 100644
index 000000000..bafe5da2b
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/CopyAndInlineStylesheet.java
@@ -0,0 +1,113 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.*;
+import org.apache.tools.ant.taskdefs.*;
+import java.io.*;
+
+public class CopyAndInlineStylesheet extends Task {
+
+    private File file;
+    public void setFile(String file) {
+        this.file = project.resolveFile(file);
+    }
+
+    private File todir;
+    public void setTodir(String todir) {
+        this.todir = project.resolveFile(todir);
+    }
+    
+
+    public void execute() throws BuildException {
+        try {
+            if (todir == null) {
+                throw new BuildException("must set 'todir' attribute");
+            }
+            if (file == null) {
+                throw new BuildException("must set 'file' attribute");
+            }
+            log("copying html from" + file + " to " + todir.getAbsolutePath());
+	    
+            File toFile = new File(todir, file.getName());
+
+            Mkdir mkdir = (Mkdir) project.createTask("mkdir");
+            mkdir.setDir(todir);
+            mkdir.execute();
+
+            BufferedReader in = new BufferedReader(new FileReader(file));
+            PrintStream out = new PrintStream(new FileOutputStream(toFile));
+
+        outer:
+            while (true) {
+                String line = in.readLine();
+                if (line == null) break;
+                if (isStyleSheet(line)) {
+                    doStyleSheet(line, out, file);
+                    while (true) {
+                        String line2 = in.readLine();
+                        if (line2 == null) break outer;
+                        out.println(line2);
+                    }
+                } else {
+                    out.println(line);
+                }
+            }
+            
+            in.close();
+            out.close();
+        } catch (IOException e) {
+            throw new BuildException(e.getMessage());
+        }
+    }
+
+    private static void doStyleSheet(String line, PrintStream out, File file) throws IOException {
+        int srcIndex = line.indexOf("href");
+        int startQuotIndex = line.indexOf('"', srcIndex);
+        int endQuotIndex = line.indexOf('"', startQuotIndex + 1);
+
+        String stylesheetLocation = line.substring(startQuotIndex + 1, endQuotIndex);
+
+        File styleSheetFile = new File(file.getParent(), stylesheetLocation);
+
+        out.println("<style type=\"text/css\">");
+        out.println("<!--");
+        
+        BufferedReader inStyle = new BufferedReader(new FileReader(styleSheetFile));
+
+        while (true) {
+            String line2 = inStyle.readLine();
+            if (line2 == null) break;
+            out.println(line2);
+        }
+        inStyle.close();
+
+        out.println("-->");
+        out.println("</style>");
+    }
+
+
+    private static boolean isStyleSheet(String line) throws IOException {
+        line = line.toLowerCase();
+        int len = line.length();
+        int i = 0; 
+
+        while (true) {
+            if (i == len) return false;
+            if (! Character.isWhitespace(line.charAt(i))) break;
+        }
+
+        return line.startsWith("<link", i);
+    }
+}
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/StripNonBodyHtml.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/StripNonBodyHtml.java
new file mode 100644
index 000000000..0a019707c
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/StripNonBodyHtml.java
@@ -0,0 +1,233 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.*;
+import org.apache.tools.ant.taskdefs.*;
+import java.io.*;
+
+/**
+ * Task to convert html source files into files with only body content.
+ *
+ * <p> This task can take the following arguments:</p>
+ *
+ * <ul>
+ *   <li>srcdir</li>
+ *   <li>destdir</li>
+ *   <li>include</li>
+ *   <li>exclude</li>
+ * </ul>
+ *
+ * <p>Of these arguments, only <b>sourcedir</b> is required.</p>
+ *
+ * <p> When this task executes, it will scan the srcdir based on the
+ * include and exclude properties.</p>
+ */
+
+public class StripNonBodyHtml extends MatchingTask {
+
+    private File srcDir;
+    private File destDir = null;
+
+    public void setSrcdir(File srcDir) {
+        this.srcDir = srcDir;
+    }
+
+    public void setDestdir(File destDir) {
+        this.destDir = destDir;
+    }
+
+    public void execute() throws BuildException {
+        if (srcDir == null) {
+            throw new BuildException("srcdir attribute must be set!");
+        }
+        if (!srcDir.exists()) {
+            throw new BuildException("srcdir does not exist!");
+        }
+        if (!srcDir.isDirectory()) {
+            throw new BuildException("srcdir is not a directory!");
+        }
+        if (destDir != null) {
+            if (!destDir.exists()) {
+                throw new BuildException("destdir does not exist!");
+            }
+            if (!destDir.isDirectory()) {
+                throw new BuildException("destdir is not a directory!");
+            }
+        }
+
+        DirectoryScanner ds = super.getDirectoryScanner(srcDir);
+        String[] files = ds.getIncludedFiles();
+
+        log("stripping " + files.length + " files");
+        int stripped = 0;
+        for (int i = 0, len = files.length; i < len; i++) {
+            if (processFile(files[i])) {
+                stripped++;
+            } else {
+                log(files[i] + " not stripped");
+            }
+        }
+        log(stripped + " files successfully stripped");
+    }
+
+    boolean processFile(String filename) throws BuildException {
+        File srcFile = new File(srcDir, filename);
+        File destFile;
+        if (destDir == null) {
+            destFile = srcFile;
+        } else {
+            destFile = new File(destDir, filename);
+            destFile.getParentFile().mkdirs();
+        }
+        try {
+            return strip(srcFile, destFile);
+        } catch (IOException e) {
+            throw new BuildException(e);
+        }
+    }
+
+    private boolean strip(File f, File g) throws IOException {
+        BufferedInputStream in =
+            new BufferedInputStream(new FileInputStream(f));
+        String s = readToString(in);
+        in.close();
+        return writeBodyTo(s, g);
+    }
+
+    private ByteArrayOutputStream temp = new ByteArrayOutputStream();
+    private byte[] buf = new byte[2048];
+
+    private String readToString(InputStream in) throws IOException {
+        ByteArrayOutputStream temp = this.temp;
+        byte[] buf = this.buf;
+        String s = "";
+        try {
+            while (true) {
+                int i = in.read(buf, 0, 2048);
+                if (i == -1) break;
+                temp.write(buf, 0, i);
+
+            }
+            s = temp.toString();
+        } finally {
+            temp.reset();
+        }
+        return s;
+    }
+
+    private boolean writeBodyTo(String s, File f) throws IOException {
+        int start, end;
+        try {
+            start = findStart(s);
+            end = findEnd(s, start);
+        } catch (ParseException e) {
+            return false; // if we get confused, just don't write the file.
+        }
+        s = processBody(s,f);
+        BufferedOutputStream out =
+            new BufferedOutputStream(new FileOutputStream(f));
+
+        out.write(s.getBytes());
+        out.close();
+        return true;
+    }
+
+    /**
+     * Process body. This implemenation strips text
+     *   between  &lt!-- start strip --&gt
+     *   and      &lt!-- end strip --&gt
+     *   inclusive.
+     */
+    private String processBody(String body, File file) {
+        if (null == body) return  body;
+        final String START = "<!-- start strip -->";
+        final String END = "<!-- end strip -->";
+        return stripTags(body, file.toString(), START, END);
+    }
+
+   /**
+     * Strip 0..n substrings in input: "s/${START}.*${END}//g"
+     * @param input the String to strip
+     * @param source the name of the source for logging purposes
+     * @param start the starting tag (case sensitive)
+     * @param end the ending tag (case sensitive)
+     */
+    String stripTags(String input, final String SOURCE, 
+                     final String START, final String END) {
+        if (null == input) return  input;
+        StringBuffer buffer = new StringBuffer(input.length());
+        String result = input;
+        int curLoc = 0;
+        while (true) {
+            int startLoc = input.indexOf(START, curLoc);
+            if (-1 == startLoc) {
+                buffer.append(input.substring(curLoc));
+                result = buffer.toString();
+                break; // <------------ valid exit
+            } else {
+                int endLoc = input.indexOf(END, startLoc);
+                if (-1 == endLoc) {
+                    log(SOURCE + " stripTags - no end tag - startLoc=" + startLoc);
+                    break; // <------------ invalid exit
+                } else if (endLoc < startLoc) { 
+                    log(SOURCE + " stripTags - impossible: startLoc=" 
+                        + startLoc + " > endLoc=" + endLoc);
+                    break; // <------------ invalid exit
+                } else {
+                    buffer.append(input.substring(curLoc, startLoc));
+                    curLoc = endLoc + END.length();
+                }
+            }
+        }
+        return result;
+    }
+
+    private int findStart(String s) throws ParseException {
+        int len = s.length();
+        int start = 0;
+        while (true) {
+            start = s.indexOf("<body", start);
+            if (start == -1) {
+                start = s.indexOf("<BODY", start);
+                if (start == -1) throw barf();
+            }
+            start = start + 5;
+            if (start >= len) throw barf();
+            char ch = s.charAt(start);
+            if (ch == '>') return start + 1;
+            if (Character.isWhitespace(ch)) {
+                start = s.indexOf('>', start);
+                if (start == -1) return -1;
+                return start + 1;
+            }
+        }
+    }
+
+    private int findEnd(String s, int start) throws ParseException {
+        int end;
+        end = s.indexOf("</body>", start);
+        if (end == -1) {
+            end = s.indexOf("</BODY>", start);
+            if (end == -1) throw barf();
+        }
+        return end;
+    }
+
+    private static class ParseException extends Exception {}
+
+    private static ParseException barf() {
+        return new ParseException();
+    }
+}
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/TestBuildModule.java b/build/src/org/aspectj/internal/tools/ant/taskdefs/TestBuildModule.java
new file mode 100644
index 000000000..374f71d79
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/TestBuildModule.java
@@ -0,0 +1,79 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.ant.taskdefs;
+
+import org.apache.tools.ant.Project;
+import org.aspectj.internal.tools.build.*;
+import org.aspectj.internal.tools.build.BuildSpec;
+import org.aspectj.internal.tools.build.Util;
+
+import java.io.File;
+import java.util.Arrays;
+
+public class TestBuildModule {
+    private static boolean REBUILD = false;
+    private static final String SYNTAX = "java {classname} <[product|module]dir>";
+    public static void main(String[] args) {
+        
+        if ((null == args) || (1 > args.length)
+            || !Util.canReadDir(new File(args[0]))) {
+            System.err.println(SYNTAX);
+            return;
+        }
+        File dir = new File(args[0]);
+        // create a module
+        if (Util.canReadDir(new File(dir, "dist"))) {
+            createProduct(args);
+        } else if (Util.canReadFile(new File(dir, ".classpath"))) {
+            createModule(args);
+        } else {
+            System.err.println(SYNTAX);
+        }
+    }
+    
+    static void createModule(String[] args) {
+        File moduleDir = new File(args[0]);
+        File baseDir = moduleDir.getParentFile();
+        if (null == baseDir) {
+            baseDir = new File(".");
+        }
+        File jarDir = new File(baseDir, "aj-build-jars");
+        if (!(Util.canReadDir(jarDir) || jarDir.mkdirs())) {
+            System.err.println("unable to create " + jarDir); 
+            return;
+        }
+        
+        // set module dir or basedir plus module name
+        BuildSpec buildSpec = new BuildSpec();
+        buildSpec.moduleDir = moduleDir;
+        buildSpec.jarDir = jarDir;
+        buildSpec.verbose = true;
+        buildSpec.failonerror = true;
+        buildSpec.trimTesting = true;
+        buildSpec.rebuild = true;
+
+        File tempDir = null;
+        Project project = new Project();
+        project.setProperty("verbose", "true");
+        project.setName("TestBuildModule.createModule" + Arrays.asList(args));
+        Builder builder = AntBuilder.getBuilder("", project, tempDir);
+        builder.build(buildSpec);
+    }
+    
+    static void createProduct(String[] args) {
+        throw new Error("unimplemented");
+    }
+}        
+
diff --git a/build/src/org/aspectj/internal/tools/ant/taskdefs/taskdefs.properties b/build/src/org/aspectj/internal/tools/ant/taskdefs/taskdefs.properties
new file mode 100644
index 000000000..37da66e9e
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/ant/taskdefs/taskdefs.properties
@@ -0,0 +1,20 @@
+ajinstaller=org.aspectj.internal.tools.ant.taskdefs.AJInstaller
+ajpush=org.aspectj.internal.tools.ant.taskdefs.AJPush
+ajbuild=org.aspectj.internal.tools.ant.taskdefs.BuildModule
+checklics=org.aspectj.internal.tools.ant.taskdefs.Checklics
+stripnonbodyhtml=org.aspectj.internal.tools.ant.taskdefs.StripNonBodyHtml
+
+# ajclean=org.aspectj.internal.tools.ant.taskdefs.AJclean
+# ajcvs=org.aspectj.internal.tools.ant.taskdefs.Ajcvs
+# ajikes=org.aspectj.internal.tools.ant.taskdefs.AJikes
+# ajinit=org.aspectj.internal.tools.ant.taskdefs.AjInit
+# checkrelease=org.aspectj.internal.tools.ant.taskdefs.Checkrelease
+# clear=org.aspectj.internal.tools.ant.taskdefs.Clear
+# inlinestylesheetaj=org.aspectj.internal.tools.ant.taskdefs.CopyAndInlineStyleshee
+# ensure=org.aspectj.internal.tools.ant.taskdefs.Ensure
+# ensureproperties=org.aspectj.internal.tools.ant.taskdefs.EnsureProperties
+# newdir=org.aspectj.internal.tools.ant.taskdefs.Newdir
+# overwrite=org.aspectj.internal.tools.ant.taskdefs.Overwrite
+# props2filters=org.aspectj.internal.tools.ant.taskdefs.Props2Filters
+# tgz=org.aspectj.internal.tools.ant.taskdefs.Tgz
+# vmcheck=org.aspectj.internal.tools.ant.taskdefs.VMCheck
diff --git a/build/src/org/aspectj/internal/tools/build/BuildSpec.java b/build/src/org/aspectj/internal/tools/build/BuildSpec.java
new file mode 100644
index 000000000..bf9ccdea8
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/BuildSpec.java
@@ -0,0 +1,161 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.build;
+
+
+import java.io.File;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Properties;
+
+/** 
+ * Open struct for specifying builds for both modules and products.
+ * Separated from bulder to permit this to build many modules
+ * concurrently.
+ * Static state has much of the Ant build properties (move?)
+ */
+public class BuildSpec {
+    public static final String baseDir_NAME = "aspectj.modules.dir";
+    public static final String stagingDir_NAME = "aj.staging.dir";
+    public static final String jarDir_NAME = "aj.jar.dir";
+    public static final String tempDir_NAME = "aj.temp.dir";
+    public static final String distDir_NAME = "aj.dist.dir";
+    
+    /** name of a system property for reading the build version */
+    public static final String SYSTEM_BUILD_VERSION_KEY = "aspectj.build.version";
+
+    /** value of the build.version if build version not defined */
+    public static final String BUILD_VERSION_DEFAULT = "DEVELOPMENT";
+
+    /** name of a filter property for the normal build version */
+    public static final String BUILD_VERSION_NAME = "build.version";
+
+    /** name of a filter property for the company */
+    public static final String COMPANY_NAME = "company.name";
+
+    /** default value of of a filter property for the company */
+    public static final String COMPANY_NAME_DEFAULT = "aspectj.org";
+
+    /** name of a filter property for the base build version (no alpha, etc.) */
+    public static final String BUILD_VERSION_BASE_NAME = "build.version.base";
+
+    /** copyright property name */
+    public static final String COPYRIGHT_NAME = "copyright.allRights.from1998";
+
+    /** overall copyright */
+    public static final String COPYRIGHT =
+       "Copyright (c) 1998-2001 Xerox Corporation, "
+       + "2002 Palo Alto Research Center, Incorporated. All rights reserved.";
+
+    /** name of a filter property for the long build version (alpha) */
+    public static final String BUILD_VERSION_LONG_NAME = "build.version.long";
+
+    /** name of a filter property for the short build version (alpha -> a, etc.) */
+    public static final String BUILD_VERSION_SHORT_NAME = "build.version.short";
+
+    /** name of a filter property for the build time */
+    public static final String BUILD_TIME_NAME = "build.time";
+
+    /** name of a filter property for the build date */
+    public static final String BUILD_DATE_NAME = "build.date";
+    
+    /** lazily and manually generate properties */
+    public static Properties getFilterProperties(long time, String longVersion) {
+        if (time < 1) {
+            time = System.currentTimeMillis();
+        }  
+        if ((null == longVersion) || (0 == longVersion.length())) {
+            longVersion = System.getProperty(
+                        BuildSpec.SYSTEM_BUILD_VERSION_KEY, 
+                        BuildSpec.BUILD_VERSION_DEFAULT);
+        }
+        Properties filterProps = new Properties();
+
+        // build time and date  XXX set in build script?
+        String timeString = time+"L";
+        // XXX wrong date format - use Version.java template format?
+        String date = new SimpleDateFormat("MMMM d, yyyy").format(new Date());
+        filterProps.setProperty(BUILD_TIME_NAME, timeString);
+        filterProps.setProperty(BUILD_DATE_NAME, date);
+
+        // build version, short build version, and base build version 
+        // 1.1alpha1,     1.1a1,               and 1.1
+        String key = BuildSpec.BUILD_VERSION_NAME;
+        String value = longVersion;
+        value = value.trim();
+        filterProps.setProperty(key, value);
+        
+        key = BuildSpec.BUILD_VERSION_LONG_NAME;
+        filterProps.setProperty(key, value);
+
+        if (!BuildSpec.BUILD_VERSION_DEFAULT.equals(value)) {
+            value = Util.shortVersion(value);
+        }
+        key = BuildSpec.BUILD_VERSION_SHORT_NAME;
+        filterProps.setProperty(key, value);
+
+        key = BuildSpec.BUILD_VERSION_BASE_NAME;
+        if (!BuildSpec.BUILD_VERSION_DEFAULT.equals(value)) {
+            int MAX = value.length();
+            for (int i = 0; i < MAX; i++) {
+                char c = value.charAt(i);
+                if ((c != '.') && ((c < '0') || (c > '9'))) {
+                    value = value.substring(0,i);
+                    break;
+                }
+            }
+        }
+        filterProps.setProperty(key, value);
+
+        // company name, copyright XXX fix company name
+        key = BuildSpec.COMPANY_NAME;
+        value = System.getProperty(key, BuildSpec.COMPANY_NAME_DEFAULT);
+        filterProps.setProperty(key, value);
+        filterProps.setProperty(BuildSpec.COPYRIGHT_NAME, BuildSpec.COPYRIGHT);
+        
+        return filterProps;
+    }
+    
+    // shared
+    public File baseDir;
+    public File moduleDir;
+    public File jarDir;
+    public File tempDir;
+    public File stagingDir;
+    public String buildConfig;   
+    public String version;
+    public boolean rebuild;
+    public boolean trimTesting;
+    public boolean assembleAll;
+    public boolean failonerror;
+    public boolean verbose;
+
+    // building products
+    public File productDir;
+    public boolean createInstaller;
+    public File distDir;
+    
+    // building modules
+    public String module;
+    
+    public String toString() { // XXX better
+        if (null != productDir) {
+            return "product " + productDir.getName();
+        } else {
+            return "module " + moduleDir.getName();
+        }
+    }
+}
+
diff --git a/build/src/org/aspectj/internal/tools/build/Builder.java b/build/src/org/aspectj/internal/tools/build/Builder.java
new file mode 100644
index 000000000..19c2ecb4b
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/Builder.java
@@ -0,0 +1,497 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.build;
+
+import org.apache.tools.ant.BuildException;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Properties;
+
+/**
+ * Template class to build (eclipse) modules (and, weakly, products),
+ * including any required modules.
+ * When building modules, this assumes:
+ * <ul>
+ * <li>the name of the module is the base name of the module directory</li>
+ * <li>all module directories are in the same base (workspace) directory</li>
+ * <li>the name of the target module jar is {moduleName}.jar</li>
+ * <li>a module directory contains a <code>.classpath</code> file with
+ *     (currently line-parseable) entries per Eclipse (XML) conventions</li>
+ * <li><code>Builder.RESOURCE_PATTERN</code> 
+ *      identifies all resources to copy to output.</li>
+ * <li>This can safely trim test-related code:
+ *     <ul>
+ *     <li>source directories named "testsrc"</li>
+ *     <li>libraries named "junit.jar"</li>
+ *     <li>required modules whose names start with "testing"</li>
+ *     </ul>
+ * <li>A file <code>{moduleDir}/{moduleName}.properties</code> 
+ *     is a property file possibly
+ *     containing entries defining requirements to be merged with the output jar
+ *     (deprecated mechanism - use assembleAll or products)</li>
+ * </ul>
+ * This currently provides no control over the compile or assembly process, 
+ * but clients can harvest <code>{moduleDir}/bin</code> directories to re-use 
+ * the results of eclipse compiles.
+ * <p>
+ * When building products, this assumes:
+ * <ul>
+ * <li>the installer-resources directory is a peer of the products directory,
+ *     itself the parent of the particular product directory.</li>
+ * <li>the dist, jar, product, and base (module) directory are set</li>
+ * <li>the product distribution consists of all (and only) the files 
+ *     in the dist sub-directory of the product directory</li> 
+ * <li>files in the dist sub-directory that are empty and end with .jar
+ *     represent modules to build, either as named or through aliases
+ *     known here.</li>
+ * <li>When assembling the distribution, all non-binary files are to 
+ *     be filtered.<li>
+ * <li>the name of the product installer is aspectj-{productName}-{version}.jar, 
+ *     where {productName} is the base name of the product directory</li>
+ * </ul>
+ * <p>
+ * When run using main(String[]), all relevant Ant libraries and properties
+ * must be defined.
+ * <p>
+ * Written to compile standalone.  Refactor if using utils, bridge, etc.
+ */
+public abstract class Builder {
+    
+    /**
+     *  This has only weak forms for build instructions needed:
+     * - resource pattern
+     * - compiler selection and control
+     * 
+     * Both assumed and generated paths are scattered;
+     * see XXXNameLiteral and XXXFileLiteral.
+     */
+    
+    public static final String RESOURCE_PATTERN
+        = "**/*.txt,**/*.rsc,**/*.gif,**/*.properties";
+
+    public static final String BINARY_SOURCE_PATTERN
+        = "**/*.rsc,**/*.gif,**/*.jar,**/*.zip";
+        
+    public static final String ALL_PATTERN = "**/*"; 
+
+    /** enable copy filter semantics */
+    protected static final boolean FILTER_ON = true;
+    
+    /** disable copy filter semantics */
+    protected static final boolean FILTER_OFF = false;
+        
+    protected final Messager handler;
+    protected boolean buildingEnabled;    
+
+    private final File tempDir;
+    private final ArrayList tempFiles;
+    private final boolean useEclipseCompiles;
+
+    protected boolean verbose;
+    protected Properties filterProps;
+    protected boolean filterSetup;
+
+    
+    protected Builder(File tempDir, boolean useEclipseCompiles,
+        Messager handler) {
+        Util.iaxIfNull(handler, "handler");
+        this.useEclipseCompiles = useEclipseCompiles;
+        this.handler = handler;
+        this.tempFiles = new ArrayList();
+        if ((null == tempDir) || !tempDir.canWrite() || !tempDir.isDirectory()) {
+            this.tempDir = Util.makeTempDir("Builder");
+        } else {
+            this.tempDir = tempDir;
+        }
+        buildingEnabled = true;
+    }
+            
+    /** tell builder to stop or that it's ok to run */
+    public void setBuildingEnabled(boolean enabled) {
+        buildingEnabled = enabled;
+        // XXX support user cancels in eclipse...
+    }
+
+    public void setVerbose(boolean verbose) {
+        this.verbose = verbose;
+    }
+    
+    public boolean build(BuildSpec buildSpec) {
+        if (!buildingEnabled) {
+            return false;
+        }
+        
+        if (null == buildSpec.productDir) { // ensure module properties
+            // derive moduleDir from baseDir + module
+            if (null == buildSpec.moduleDir) { 
+                if (null == buildSpec.baseDir) {
+                    throw new BuildException("require baseDir or moduleDir");
+                } else if (null == buildSpec.module) {
+                    throw new BuildException("require module with baseDir");
+                } else {
+                    if (null == buildSpec.baseDir) {
+                       buildSpec.baseDir  = new File("."); // user.home?
+                    }
+                    buildSpec.moduleDir = new File(buildSpec.baseDir, buildSpec.module);
+                }
+            } else if (null == buildSpec.baseDir) { // derive baseDir from moduleDir parent
+                buildSpec.baseDir = buildSpec.moduleDir.getParentFile();  // rule: base is parent
+                if (null == buildSpec.baseDir) {
+                    buildSpec.baseDir = new File("."); // user.home?
+                }
+            }
+            Util.iaxIfNotCanReadDir(buildSpec.moduleDir, "moduleDir");
+            
+            if (null == buildSpec.module) {              // derive module name from directory
+                buildSpec.module = buildSpec.moduleDir.getName();
+                if (null == buildSpec.module) {
+                    throw new BuildException("no name, even from " + buildSpec.moduleDir);
+                }
+            }
+        }
+        
+        if (null != buildSpec.productDir) {
+            return buildProduct(buildSpec);
+        }
+        if (buildSpec.trimTesting && (-1 != buildSpec.module.indexOf("testing"))) {  // XXXNameLiteral
+            String warning = "Warning - cannot trimTesting for testing modules: ";
+            handler.log(warning + buildSpec.module);
+        }
+        Messager handler = new Messager();
+        Modules modules = new Modules(buildSpec.baseDir, buildSpec.jarDir, buildSpec.trimTesting, handler);
+                           
+        final Module moduleToBuild = modules.getModule(buildSpec.module);
+        ArrayList errors = new ArrayList();
+        try {
+            return buildAll(
+                moduleToBuild, 
+                errors, 
+                buildSpec.rebuild, 
+                buildSpec.assembleAll);
+        } finally {
+            if (0 < errors.size()) {
+                String label = "error building " + buildSpec + ": ";
+                for (Iterator iter = errors.iterator(); iter.hasNext();) {
+                    handler.error(label + iter.next());
+                }
+            }
+        }
+    }
+    
+    /**
+     * Clean up any temporary files, etc. after build completes
+     */
+    public boolean cleanup() {
+        boolean noErr = true;
+        for (ListIterator iter = tempFiles.listIterator(); iter.hasNext();) {
+			File file = (File) iter.next();
+            if (!Util.deleteContents(file) || !file.delete()) {
+                if (noErr) {
+                    noErr = false;
+                }
+                handler.log("unable to clean up " + file);
+            }			
+		}
+        return noErr;
+    }
+
+    /**
+     * Build a module with all antecedants.
+     * @param module the Module to build
+     * @param errors the List sink for errors, if any
+     * @return false after successful build, when module jar should exist
+     */
+    protected boolean buildAll(Module module, List errors, boolean rebuild, boolean assembleAll) {
+        String[] buildList = getAntecedantModuleNames(module, rebuild);
+        if ((null != buildList) && (0 < buildList.length)) {
+            final Modules modules = module.getModules();
+            final Messager handler = this.handler;
+            final boolean log = (verbose && (null != handler));
+            final boolean verbose = this.verbose;
+            if (log) {
+                handler.log("modules to build: " + Arrays.asList(buildList));
+            }
+            for (int i = 0; i < buildList.length; i++) {
+                
+                if (!buildingEnabled) {
+                    return false;
+                }
+                String modName = buildList[i];
+                if (log) {
+                    handler.log("building " + modName);
+                }
+                Module next = modules.getModule(modName);
+                if (!buildOnly(next, errors)) {
+                    return false;
+                }
+            }
+        }
+        if (assembleAll && !assembleAll(module, handler)) {
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Build a module but no antecedants.
+     * @param module the Module to build
+     * @param errors the List sink for errors, if any
+     * @return false after successful build, when module jar should exist
+     */
+    protected boolean buildOnly(Module module, List errors) {
+        if (!buildingEnabled) {
+            return false;
+        }
+        File classesDir = useEclipseCompiles 
+            ? new File(module.moduleDir, "bin")  // XXXFileLiteral
+            : new File(tempDir, "classes-" + System.currentTimeMillis()); 
+        if (verbose) {
+            handler.log("buildOnly " + module);
+        }
+        try {
+            return (useEclipseCompiles || compile(module, classesDir, errors)) 
+                    && assemble(module, classesDir, errors);
+        } finally {
+            if (!useEclipseCompiles
+                && (!Util.deleteContents(classesDir) || !classesDir.delete())) {
+                errors.add("unable to delete " + classesDir);
+            }
+        }
+    }
+    
+    /**
+     * Register temporary file or directory to be deleted when
+     * the build is complete, even if an Exception is thrown.
+     */
+    protected void addTempFile(File tempFile) {
+        if (null != tempFile) {
+            tempFiles.add(tempFile);
+        }
+    }
+    /**
+     * Build product by discovering any modules to build,
+     * building those, assembling the product distribution,
+     * and optionally creating an installer for it.
+     * @return true on success
+     */
+    protected boolean buildProduct(BuildSpec buildSpec) 
+        throws BuildException {
+        Util.iaxIfNull(buildSpec, "buildSpec");
+        // XXX if installer and not out of date, do not rebuild unless rebuild set
+
+        if (!buildSpec.trimTesting) {
+            buildSpec.trimTesting = true;
+            handler.log("testing trimmed for " + buildSpec);
+        }
+        Util.iaxIfNotCanReadDir(buildSpec.productDir, "productDir");
+        Util.iaxIfNotCanReadDir(buildSpec.baseDir, "baseDir");
+        Util.iaxIfNotCanWriteDir(buildSpec.distDir, "distDir");
+
+        // ---- discover modules to build, and build them
+        Modules modules = new Modules(
+            buildSpec.baseDir, 
+            buildSpec.jarDir, 
+            buildSpec.trimTesting, 
+            handler);
+        ProductModule[] productModules = discoverModules(buildSpec.productDir, modules);
+        for (int i = 0; i < productModules.length; i++) {
+            if (buildSpec.verbose) {
+                handler.log("building product module " + productModules[i]); 
+            }
+            if (!buildProductModule(productModules[i])) {
+                return false;
+            }
+        }
+        if (buildSpec.verbose) {
+            handler.log("assembling product module for " + buildSpec); 
+        }
+        
+        // ---- assemble product distribution
+        final String productName = buildSpec.productDir.getName();
+        final File targDir = new File(buildSpec.distDir, productName);
+        final String targDirPath = targDir.getPath();
+        if (targDir.canWrite()) {
+            Util.deleteContents(targDir);
+        }
+        
+        if (!targDir.canWrite() && !targDir.mkdirs()) {
+            if (buildSpec.verbose) {
+                handler.log("unable to create " + targDir);
+            }
+            return false;
+        }
+        // filter-copy everything but the binaries
+        File distDir = new File(buildSpec.productDir, "dist");       // XXXFileLiteral
+        String excludes = Builder.BINARY_SOURCE_PATTERN;
+        String includes = Builder.ALL_PATTERN;
+        if (!copyFiles(distDir, targDir, includes, excludes, FILTER_ON)) {
+            return false;
+        }
+        
+        // copy binaries (but not module flag files)       
+        excludes = null;
+        {
+            StringBuffer buf = new StringBuffer();        
+            for (int i = 0; i < productModules.length; i++) {
+                if (0 < buf.length()) {
+                    buf.append(",");
+                }
+                buf.append(productModules[i].relativePath);
+            }
+            if (0 < buf.length()) {
+                excludes = buf.toString();
+            }
+        }
+        includes = Builder.BINARY_SOURCE_PATTERN;
+        if (!copyFiles(distDir, targDir, includes, excludes, FILTER_OFF)) {
+            return false;
+        }
+
+        // copy binaries associated with module flag files
+        for (int i = 0; i < productModules.length; i++) {
+            ProductModule product = productModules[i];
+            String targPath = targDirPath + "/" + product.relativePath;
+            File jarFile = (product.assembleAll 
+                ? product.module.getAssembledJar()
+                : product.module.getModuleJar() );
+            copyFile(jarFile, new File(targPath), FILTER_OFF);
+        } 
+        handler.log("created product in " + targDir);
+
+        // ---- create installer 
+        if (buildSpec.createInstaller) {
+            return buildInstaller(buildSpec, targDirPath);
+        } else {
+            return true;
+        }
+    }
+    
+    protected boolean buildProductModule(ProductModule module) {
+        boolean noRebuild = false;
+        ArrayList errors = new ArrayList();
+        try {
+            return buildAll(module.module, errors, noRebuild,  module.assembleAll);
+        } finally {
+            for (Iterator iter = errors.iterator(); iter.hasNext();) {
+                handler.error("error building " + module + ": " + iter.next());                
+            }
+        }
+    }
+    
+    /**
+     * Discover any modules that might need to be built
+     * in order to assemble the product distribution.
+     * This interprets empty .jar files as module deliverables.
+     */
+    protected ProductModule[] discoverModules(File productDir, Modules modules) {
+        final ArrayList found = new ArrayList();
+        FileFilter filter = new FileFilter() {
+            public boolean accept(File file) {
+                if ((null != file) 
+                    && file.canRead()
+                    && file.getPath().endsWith(".jar")   // XXXFileLiteral
+                    && (0l == file.length())) {
+                    found.add(file);
+                }
+                return true;
+            }
+        };
+        Util.visitFiles(productDir, filter);
+        ArrayList results = new ArrayList();
+        for (Iterator iter = found.iterator(); iter.hasNext();) {
+            File file = (File) iter.next();
+            String jarName = moduleAliasFor(file.getName().toLowerCase());
+            if (jarName.endsWith(".jar") || jarName.endsWith(".zip")) {   // XXXFileLiteral
+                jarName = jarName.substring(0, jarName.length()-4);
+            } else {
+                handler.log("can only replace .[jar|zip]: " + file); // XXX error?
+            }
+            boolean assembleAll = jarName.endsWith("-all");  // XXXFileLiteral
+            String name = (!assembleAll ? jarName : jarName.substring(0, jarName.length()-4));
+            Module module = modules.getModule(name);
+            if (null == module) {
+                handler.log("unable to find module for " + file);
+            } else {
+                results.add(new ProductModule(productDir, file, module, assembleAll));
+            }
+        }
+        return (ProductModule[]) results.toArray(new ProductModule[0]);
+    }
+
+    /**
+     * Map delivered-jar name to created-module name
+     * @param jarName the String (lowercased) of the jar/zip to map
+     */
+    protected String moduleAliasFor(String jarName) {
+        if ("aspectjtools.jar".equals(jarName)) {    // XXXFileLiteral
+            return "ajbrowser-all.jar";
+        } else if ("aspectjrt.jar".equals(jarName)) {
+            return "runtime.jar";
+        } else {
+            return jarName;
+        }
+    }
+    
+    /** 
+     * @return String[] names of modules to build for this module
+     */
+    abstract protected String[] getAntecedantModuleNames(Module toBuild, boolean rebuild);
+
+    /**
+     * Compile module classes to classesDir, saving String errors.
+     */
+    abstract protected boolean compile(Module module, File classesDir, List errors);
+
+    /**
+     * Assemble the module distribution from the classesDir, saving String errors.
+     */
+    abstract protected boolean assemble(Module module, File classesDir, List errors);
+
+    /**
+     * Assemble the module distribution from the classesDir and all antecendants, 
+     * saving String errors.
+     */
+    abstract protected boolean assembleAll(Module module, Messager handler);
+
+    /**
+     * Generate the installer for this product to targDirPath
+     */
+    abstract protected boolean buildInstaller(BuildSpec buildSpec, String targDirPath);
+
+    /** 
+     * Copy fromFile to toFile, optionally filtering contents
+     */
+    abstract protected boolean copyFile(File fromFile, File toFile, boolean filter);
+    
+    /** 
+     * Copy toDir any fromDir included files without any exluded files, 
+     * optionally filtering contents.
+     * @param fromDir File dir to read from - error if not readable
+     * @param toDir File dir to write to - error if not writable
+     * @param included String Ant pattern of included files (if null, include all)
+     * @param excluded String Ant pattern of excluded files (if null, exclude none)
+     * @param filter if FILTER_ON, then filter file contents using global token/value pairs
+     */
+    abstract protected boolean copyFiles(File fromDir, File toDir, String included, String excluded, boolean filter);
+}
+        
+
+
diff --git a/build/src/org/aspectj/internal/tools/build/Messager.java b/build/src/org/aspectj/internal/tools/build/Messager.java
new file mode 100644
index 000000000..c7b12d4a9
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/Messager.java
@@ -0,0 +1,43 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.build;
+
+/** logging stub XXX replace */
+public class Messager {
+    public Messager() {
+    }
+    public boolean log(String s) {
+        System.out.println(s);
+        return true;
+    }
+    
+    public boolean error(String s) {
+        System.out.println(s);
+        return true;
+    }
+    
+    public boolean logException(String context, Throwable thrown) {
+        System.err.println(context);
+        thrown.printStackTrace(System.err);
+        return true;
+    }
+}
+
+
+
+
+
+
+
diff --git a/build/src/org/aspectj/internal/tools/build/Module.java b/build/src/org/aspectj/internal/tools/build/Module.java
new file mode 100644
index 000000000..9c6022d18
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/Module.java
@@ -0,0 +1,501 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.build;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Properties;
+import java.util.StringTokenizer;
+
+/**
+ * This represents an (eclipse) build module/unit 
+ * used by a Builder to compile classes 
+ * and/or assemble zip file
+ * of classes, optionally with all antecedants.
+ * This implementation infers attributes from two
+ * files in the module directory:
+ * <ul>
+ * <li>an Eclipse project <code>.classpath</code> file
+ *     containing required libraries and modules
+ *     (collectively, "antecedants")
+ *     </li>
+ * <li>a file <code>{moduleName}.mf.txt</code> is taken as
+ *     the manifest of any .jar file produced, after filtering.
+ *     </li>
+ * </ul>
+ * 
+ * @see Builder
+ * @see Modules#getModule(String)
+ */
+public class Module {
+    
+    /** @return true if file is null or cannot be read or was
+     *           last modified after time
+     */
+    private static boolean outOfDate(long time, File file) {
+        return ((null == file) 
+            || !file.canRead()
+            || (file.lastModified() > time));
+    }
+    
+	/** @return all source files under srcDir */
+	private static Iterator sourceFiles(File srcDir) {
+        ArrayList result = new ArrayList();
+        sourceFiles(srcDir, result);
+        return result.iterator();
+    }
+    
+	private static void sourceFiles(File srcDir, List result) {
+        if ((null == srcDir) || !srcDir.canRead() || !srcDir.isDirectory()) {
+            return;
+        }
+        File[] files = srcDir.listFiles();
+        for (int i = 0; i < files.length; i++) {
+			if (files[i].isDirectory()) {
+                sourceFiles(files[i], result);
+            } else if (isSourceFile(files[i])) {
+                result.add(files[i]);
+            }
+		}
+	}
+
+    /** 
+     * Recursively find antecedant jars. 
+     * @see findKnownJarAntecedants()
+     */
+    private static void doFindKnownJarAntecedants(Module module, ArrayList known) {
+        Util.iaxIfNull(module, "module");
+        Util.iaxIfNull(known, "known");
+        
+        for (Iterator iter = module.getLibJars().iterator(); iter.hasNext();) {
+            File libJar = (File) iter.next();
+            if (!skipLibraryJarAntecedant(libJar)
+                && !known.contains(libJar)) { // XXX what if same referent, diff path...
+                known.add(libJar);
+            }
+        }
+        for (Iterator iter = module.getRequired().iterator(); iter.hasNext();) {
+            Module required = (Module) iter.next();
+            File requiredJar = required.getModuleJar();
+            if (!known.contains(requiredJar)) {
+                known.add(requiredJar);
+                doFindKnownJarAntecedants(required, known);
+            }
+        }
+    }
+    
+    /** XXX gack explicitly skip Ant */
+    private static boolean skipLibraryJarAntecedant(File libJar) {
+        if (null == libJar) {
+            return true;
+        }
+        String path = libJar.getPath().replace('\\', '/');
+        return (-1 == path.indexOf("/lib/ant/lib/"));
+    }
+
+	/**@return true if this is a source file */
+	private static boolean isSourceFile(File file) {
+        String path = file.getPath();
+        return (path.endsWith(".java") || path.endsWith(".aj"));   // XXXFileLiteral
+	}
+    
+    public final boolean valid;
+
+    public final File moduleDir;
+
+    public final String name;
+
+    /** reference back to collection for creating required modules */
+    final Modules modules;
+    
+    /** path to output jar - may not exist */
+    private final File moduleJar;
+    
+    /** path to fully-assembed jar - may not exist */
+    private final File assembledJar;
+    
+    /** File list of library jars */
+    private final List libJars;
+
+    /** File list of source directories */
+    private final List srcDirs;
+
+    /** properties from the modules {name}.properties file */
+    private final Properties properties;
+
+    /** Module list of required modules */
+    private final List required;
+    
+    /** List of File that are newer than moduleJar.  Null until requested */
+    //private List newerFiles;
+    /** true if this has been found to be out of date */
+    private boolean outOfDate;
+    
+    /** true if we have calculated whether this is out of date */
+    private boolean outOfDateSet;
+    
+    /** if true, trim testing-related source directories, modules, and libraries */
+    private final boolean trimTesting;
+    
+    /** logger */
+    private final Messager messager;
+    
+    Module(File moduleDir, 
+        File jarDir, 
+        String name, 
+        Modules modules, 
+        boolean trimTesting,
+        Messager messager) {
+        Util.iaxIfNotCanReadDir(moduleDir, "moduleDir");
+        Util.iaxIfNotCanReadDir(jarDir, "jarDir");
+        Util.iaxIfNull(name, "name");
+        Util.iaxIfNull(modules, "modules");
+        this.moduleDir = moduleDir;
+        this.trimTesting = trimTesting;
+        this.libJars = new ArrayList();
+        this.required = new ArrayList();
+        this.srcDirs = new ArrayList();
+        this.properties = new Properties();
+        this.name = name;
+        this.modules = modules;
+        this.messager = messager;
+        this.moduleJar = new File(jarDir, name + ".jar");       
+        this.assembledJar = new File(jarDir, name + "-all.jar");       
+        valid = init();
+    }
+        
+    /** @return path to output jar - may not exist */
+    public File getModuleJar() {
+        return moduleJar;
+    }
+    
+    /** @return path to output assembled jar - may not exist */
+    public File getAssembledJar() {
+        return assembledJar;
+    }
+    
+    /** @return unmodifiable List of required modules String names*/
+    public List getRequired() {
+        return Collections.unmodifiableList(required);
+    }
+    
+    /** @return unmodifiable list of required library files, guaranteed readable */
+    public List getLibJars() {
+        return Collections.unmodifiableList(libJars);
+    }
+    
+    /** @return unmodifiable list of source directories, guaranteed readable */
+    public List getSrcDirs() {
+        return Collections.unmodifiableList(srcDirs);
+    }
+    
+    /** @return Modules registry of known modules, including this one */
+    public Modules getModules() {
+        return modules;
+    }
+    
+    /** @return List of File jar paths to be merged into module-dist */
+    public List getMerges() {
+        String value = properties.getProperty(name + ".merges");
+        if ((null == value) || (0 == value.length())) {
+            return Collections.EMPTY_LIST;
+        }
+        ArrayList result = new ArrayList();
+        StringTokenizer st = new StringTokenizer(value);
+        while (st.hasMoreTokens()) {
+            result.addAll(findJarsBySuffix(st.nextToken()));
+        }
+        return result;
+    }
+    
+   
+    public void clearOutOfDate() {
+        outOfDate = false;
+        outOfDateSet = false;
+    }
+    
+    /**
+     * @param recalculate if true, then force recalculation 
+     * @return true if the target jar for this module is older than
+     *          any source files in a source directory
+     *          or any required modules
+     *          or any libraries
+     *          or if any libraries or required modules are missing
+     */
+    public boolean outOfDate(boolean recalculate) {
+        if (recalculate) {
+            outOfDateSet = false;
+        }
+        if (!outOfDateSet) {
+            outOfDate = false;
+            try {
+                if (!(moduleJar.exists() && moduleJar.canRead())) {
+                    return outOfDate = true;
+                }
+                final long time = moduleJar.lastModified();
+                File file;
+                for (Iterator iter = srcDirs.iterator(); iter.hasNext();) {
+                  File srcDir = (File) iter.next();
+                    for (Iterator srcFiles = sourceFiles(srcDir); srcFiles.hasNext();) {
+                        file = (File) srcFiles.next();
+                        if (outOfDate(time, file)) {
+                            return outOfDate = true;
+                        }
+                    }
+                }
+                // required modules
+                for (Iterator iter = getRequired().iterator(); iter.hasNext();) {
+                    Module required = (Module) iter.next();
+                    file = required.getModuleJar();
+                    if (outOfDate(time, file)) {
+                        return outOfDate = true;
+                    }
+                }
+                // libraries
+                for (Iterator iter = getLibJars().iterator(); iter.hasNext();) {
+                    file = (File) iter.next();
+                    if (outOfDate(time, file)) {
+                        return outOfDate = true;
+                    }
+                }
+            } finally {
+                outOfDateSet = true;
+            }
+        }
+        return outOfDate;
+    }
+    /**
+     * Add any (File) library jar  or (File) required module jar
+     * to the List known, if not added already.
+     */
+    public ArrayList findKnownJarAntecedants() {
+        ArrayList result = new ArrayList();
+        doFindKnownJarAntecedants(this, result);
+        return result;   
+    }
+    
+    public String toString() {
+        return name;
+    }
+
+    public String toLongString() {
+        return  
+            "Module [name="
+            + name
+            + ", srcDirs="
+            + srcDirs
+            + ", required="
+            + required
+            + ", moduleJar="
+            + moduleJar
+            + ", libJars="
+            + libJars
+            + "]";
+    }
+
+    private boolean init() {
+        return initClasspath() && initProperties() && reviewInit();
+    }
+
+    /** read eclipse .classpath file XXX line-oriented hack */
+    private boolean initClasspath() {
+        // meaning testsrc directory, junit library, etc.
+        File file = new File(moduleDir, ".classpath");   // XXXFileLiteral
+        FileReader fin = null;
+        try {
+            fin = new FileReader(file);
+            BufferedReader reader = new BufferedReader(fin);
+            String line;
+            String lastKind = null;
+            while (null != (line = reader.readLine())) {
+                lastKind = parseLine(line, lastKind);
+            }
+            return (0 < srcDirs.size());
+        } catch (IOException e) {
+            messager.logException("IOException reading " + file, e);
+        } finally {
+            if (null != fin) {
+                try { fin.close(); }
+                catch (IOException e) {} // ignore
+            }
+        }
+        return false;
+    }
+
+    /** @return true if any properties were read correctly */
+    private boolean initProperties() {
+        File file = new File(moduleDir, name + ".properties");   // XXXFileLiteral
+        if (!Util.canReadFile(file)) {
+            return true; // no properties to read
+        }
+        FileInputStream fin = null;
+        try {
+            fin = new FileInputStream(file);
+            properties.load(fin);
+            return true;
+        } catch (IOException e) {
+            messager.logException("IOException reading " + file, e);
+            return false;
+        } finally {
+            if (null != fin) {
+                try { fin.close(); }
+                catch (IOException e) {} // ignore
+            }
+        }
+    }
+    
+    /** 
+     * Post-process initialization.  
+     * This implementation trims testing-related source 
+     * directories, libraries, and modules if trimTesting is enabled/true.  
+     * To build testing modules, trimTesting must be false.
+     * @return true if initialization post-processing worked 
+     */
+    protected boolean reviewInit() {   
+        if (!trimTesting) {
+            return true;
+        }
+        try {
+            for (ListIterator iter = srcDirs.listIterator(); iter.hasNext();) {
+    			File srcDir = (File) iter.next();
+    		    String name = srcDir.getName();
+                if ("testsrc".equals(name.toLowerCase())) { // XXXFileLiteral
+                    iter.remove(); // XXX if verbose log
+                }	
+    		}
+            for (ListIterator iter = libJars.listIterator(); iter.hasNext();) {
+                File libJar = (File) iter.next();
+                String name = libJar.getName();
+                if ("junit.jar".equals(name.toLowerCase())) {  // XXXFileLiteral              
+                    iter.remove(); // XXX if verbose log
+                }   
+            }
+            for (ListIterator iter = required.listIterator(); iter.hasNext();) {
+                Module required = (Module) iter.next();
+                String name = required.name;
+                // XXX testing-util only ?
+                if (name.toLowerCase().startsWith("testing")) {  // XXXFileLiteral
+                    iter.remove(); // XXX if verbose log
+                }   
+            }
+        } catch (UnsupportedOperationException e) {
+            return false; // failed XXX log also if verbose
+        }
+        return true;
+    }
+    
+    private String parseLine(String line, String lastKind) {
+        if (null == line) {
+            return null;
+        }
+        String kind;
+        int loc = line.indexOf("kind=\"");
+        if ((-1 == loc) || (loc + 9 > line.length())) {
+            // no kind string - fail unless have lastKind
+            if (null == lastKind) {
+                return null; 
+            } else {
+                kind = lastKind;
+            }
+        } else { // have kind string - get kind
+            loc += 6; // past kind="
+            kind = line.substring(loc, loc+3);
+        }
+        
+        // now look for value
+        loc = line.indexOf("path=\"");
+        if (-1 == loc)  { // no value - return lastKind
+            return kind;
+        } 
+        loc += 6; // past path="
+        int end = line.indexOf("\"", loc);
+        if (-1 == end) {
+            throw new Error("unterminated path in " + line);
+        } 
+        final String path = line.substring(loc, end);
+        
+        if ("src".equals(kind)) {
+            if (path.startsWith("/")) { // module
+                String moduleName = path.substring(1);
+                Module req = modules.getModule(moduleName);
+                if (null != req) {
+                    required.add(req);
+                } else {
+                    messager.error("unable to create required module: " + moduleName);
+                }                
+            } else {                    // src dir
+                File srcDir = new File(moduleDir, path);
+                if (srcDir.canRead() && srcDir.isDirectory()) {
+                    srcDirs.add(srcDir); 
+                } else {
+                    messager.error("not a src dir: " + srcDir);
+                }
+            }
+        } else if ("lib".equals(kind)) {
+            String libPath = path.startsWith("/") 
+                ? modules.baseDir.getAbsolutePath() + path
+                : path;
+             File libJar = new File(libPath);
+             if (libJar.canRead() && libJar.isFile()) {
+                libJars.add(libJar);
+             } else {
+                messager.error("no such library jar " + libJar + " from " + line);                
+             }
+        } else if ("var".equals(kind)) {
+            if (!"JRE_LIB".equals(path)) {
+                messager.log("cannot handle var yet: " + line);
+            }
+        } else if ("con".equals(kind)) {
+            messager.log("cannot handle con yet: " + line);
+        } else if ("out".equals(kind)) {
+            // ignore output entries
+        } else {
+            messager.log("unrecognized kind " + kind + " in " + line);
+        }
+        return null;
+    }
+    
+    /** @return List of File of any module or library jar ending with suffix */
+    private ArrayList findJarsBySuffix(String suffix) {
+        ArrayList result = new ArrayList();
+        if (null != suffix) {
+            // library jars
+            for (Iterator iter = getLibJars().iterator(); iter.hasNext();) {
+                File file = (File) iter.next();
+                if (file.getPath().endsWith(suffix)) {
+                    result.add(file);
+                }
+            }
+            // module jars
+            for (Iterator iter = getRequired().iterator(); iter.hasNext();) {
+                Module module = (Module) iter.next();
+                File file = module.getModuleJar();
+                if (file.getPath().endsWith(suffix)) {
+                    result.add(file);
+                }
+            }
+        }
+        return result;
+    }
+}
+    
diff --git a/build/src/org/aspectj/internal/tools/build/Modules.java b/build/src/org/aspectj/internal/tools/build/Modules.java
new file mode 100644
index 000000000..55b2fa800
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/Modules.java
@@ -0,0 +1,68 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.build;
+
+import java.io.File;
+import java.util.Hashtable;
+
+/** 
+ * Registration and factory for modules 
+ * @see Module
+ * @see Builder
+ */
+public class Modules {
+    
+    private final Hashtable modules = new Hashtable();
+    public final File baseDir;
+    public final File jarDir;
+    private final Messager handler;
+    public final boolean trimTesting;
+    
+    public Modules(File baseDir, File jarDir, boolean trimTesting, Messager handler) {
+        this.baseDir = baseDir;
+        this.jarDir = jarDir;
+        this.handler = handler;
+        this.trimTesting = trimTesting;
+        Util.iaxIfNotCanReadDir(baseDir, "baseDir");
+        Util.iaxIfNotCanReadDir(jarDir, "jarDir");
+        Util.iaxIfNull(handler, "handler");
+    }
+    
+        
+    /** 
+     * Get module associated with name.
+     * @return fail if unable to find or create module {name}.
+     */
+    public Module getModule(String name) {
+        if (null == name) {
+            return null;
+        }
+        Module result = (Module) modules.get(name);
+        if (null == result) {
+            File moduleDir = new File(baseDir, name);
+            if (!Util.canReadDir(moduleDir)) {
+                handler.error("not a module: " + name);
+            } else {
+                result = new Module(moduleDir, jarDir, name, this, trimTesting, handler);
+                if (result.valid) {
+                    modules.put(name, result);
+                } else {
+                    handler.error("invalid module: " + result.toLongString());
+                }
+            }         
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/build/src/org/aspectj/internal/tools/build/ProductModule.java b/build/src/org/aspectj/internal/tools/build/ProductModule.java
new file mode 100644
index 000000000..90e6f3879
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/ProductModule.java
@@ -0,0 +1,70 @@
+/* *******************************************************************
+ * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+package org.aspectj.internal.tools.build;
+
+import java.io.File;
+
+/**
+ * Struct associating module with target product distribution jar
+ * and assembly instructions.
+ * When building product distributions, a zero-length jar file 
+ * in the dist directory may signify a module to be built, 
+ * renamed, and included in the distribution.
+ */
+public class ProductModule {
+    /** name of distribution directory in product directory */
+    private static final String DIST = "dist";
+    
+    /** top-level product directory being produced */
+    public final File productDir;
+    
+    /** path to file in distribution template dir for this module jar */
+    public final File replaceFile;
+    
+    /** relative path within distribution of this product module jar */
+    public final String relativePath;
+    
+    /** the module jar is the file to replace */
+    public final Module module;
+
+    /** if true, assemble all when building module */
+    public final boolean assembleAll;
+    
+    public ProductModule(File productDir, File replaceFile, Module module, boolean assembleAll) {
+        this.replaceFile = replaceFile;
+        this.module = module;
+        this.productDir = productDir;
+        this.assembleAll = assembleAll;
+        Util.iaxIfNull(module, "module");
+        Util.iaxIfNotCanReadDir(productDir, "productDir");
+        Util.iaxIfNotCanReadFile(replaceFile, "replaceFile");
+        String productDirPath = productDir.getAbsolutePath();
+        String replaceFilePath = replaceFile.getAbsolutePath();
+        if (!replaceFilePath.startsWith(productDirPath)) {
+            String m = "\"" + replaceFilePath 
+                + "\" does not start with \""
+                + productDirPath
+                + "\"";
+            throw new IllegalArgumentException(m);
+        }
+        replaceFilePath = replaceFilePath.substring(1+productDirPath.length());
+        if (!replaceFilePath.startsWith(DIST)) {
+            String m = "\"" + replaceFilePath 
+                + "\" does not start with \"" + DIST + "\"";
+            throw new IllegalArgumentException(m);
+        }
+        relativePath = replaceFilePath.substring(1 + DIST.length());
+    }
+    public String toString() {
+        return "" + module + " for " + productDir;
+    }
+}
diff --git a/build/src/org/aspectj/internal/tools/build/Util.java b/build/src/org/aspectj/internal/tools/build/Util.java
new file mode 100644
index 000000000..27ca9e1b4
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/Util.java
@@ -0,0 +1,174 @@
+/* *******************************************************************
+ * Copyright (c) 1999-2001 Xerox Corporation, 
+ *               2002 Palo Alto Research Center, Incorporated (PARC).
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Common Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://www.eclipse.org/legal/cpl-v10.html 
+ *  
+ * Contributors: 
+ *     Xerox/PARC     initial implementation 
+ * ******************************************************************/
+
+ 
+package org.aspectj.internal.tools.build;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+/** 
+ * Build-only utilities.
+ * Many mirror utils module APIs.
+ */
+public class Util {
+
+    /** 
+     * Map version in long form to short, 
+     * e.g., replacing "alpha" with "a"
+     */
+    public static String shortVersion(String version) {
+        version = Util.replace(version, "alpha", "a");
+        version = Util.replace(version, "beta", "b");
+        version = Util.replace(version, "candidate", "rc");
+        version = Util.replace(version, "development", "d");
+        version = Util.replace(version, "dev", "d");
+        return version;
+    }
+    
+    /**
+     * Replace any instances of {replace} in {input} with {with}.
+     * @param input the String to search/replace
+     * @param replace the String to search for in input
+     * @param with the String to replace with in input
+     * @return input if it has no replace, otherwise a new String
+     */
+    public static String replace(String input, String replace, String with) {
+        int loc = input.indexOf(replace);
+        if (-1 != loc) {
+            String result = input.substring(0, loc);
+            result += with;
+            int start = loc + replace.length();
+            if (start < input.length()) {
+                result += input.substring(start);
+            }
+            input = result;
+        }
+        return input;
+    }
+
+    /** @return false if filter returned false for any file in baseDir subtree */
+    public static boolean visitFiles(File baseDir, FileFilter filter) {
+        Util.iaxIfNotCanReadDir(baseDir, "baseDir");
+        Util.iaxIfNull(filter, "filter");
+        File[] files = baseDir.listFiles();
+        boolean passed = true;
+        for (int i = 0; passed && (i < files.length); i++) {
+			passed = files[i].isDirectory()
+                ? visitFiles(files[i], filter)
+                : filter.accept(files[i]);
+		}
+        return passed;
+    }
+    
+    /** @throws IllegalArgumentException if cannot read dir */
+    public static void iaxIfNotCanReadDir(File dir, String name) {
+        if (!canReadDir(dir)) {
+            throw new IllegalArgumentException(name + " dir not readable: " + dir);
+        }
+    }
+    
+    /** @throws IllegalArgumentException if cannot read file */
+    public static void iaxIfNotCanReadFile(File file, String name) {
+        if (!canReadFile(file)) {
+            throw new IllegalArgumentException(name + " file not readable: " + file);
+        }
+    }
+    
+    /** @throws IllegalArgumentException if cannot write dir */
+    public static void iaxIfNotCanWriteDir(File dir, String name) {
+        if (!canWriteDir(dir)) {
+            throw new IllegalArgumentException(name + " dir not writeable: " + dir);
+        }
+    }
+    
+    /** @throws IllegalArgumentException if input is null */
+    public static void iaxIfNull(Object input, String name) {
+        if (null == input) {
+            throw new IllegalArgumentException("null " + name);
+        }
+    }
+    
+    /** render exception to String */
+    public static String renderException(Throwable thrown) {
+        if (null == thrown) {
+            return "(Throwable) null";
+        }
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw, true);
+        pw.println(thrown.getMessage());
+        thrown.printStackTrace(pw); 
+        pw.flush();
+        return sw.getBuffer().toString(); 
+    }
+    
+    /** @return true if dir is a writable directory */
+    public static boolean canWriteDir(File dir) {
+        return (null != dir) && dir.canWrite() && dir.isDirectory();
+    }
+    
+    /** @return true if dir is a readable directory */
+    public static boolean canReadDir(File dir) {
+        return (null != dir) && dir.canRead() && dir.isDirectory();
+    }
+    
+    /** @return true if dir is a readable file */
+    public static boolean canReadFile(File file) {
+        return (null != file) && file.canRead() && file.isFile();
+    }
+    
+    /** 
+     * Delete contents of directory.
+     * The directory itself is not deleted.
+     * @param dir the File directory whose contents should be deleted.
+     * @return true if all contents of dir were deleted 
+     */
+    public static boolean deleteContents(File dir) {
+        if ((null == dir) || !dir.canWrite()) {
+            return false;
+        } else if (dir.isDirectory()) {
+            File[] files = dir.listFiles();
+            for (int i = 0; i < files.length; i++) {
+				if (!deleteContents(files[i]) || !files[i].delete()) {
+                    return false;
+                }
+			}
+        }
+        return true;
+    }
+    
+    /** @return File temporary directory with the given prefix */
+    public static File makeTempDir(String prefix) {
+        if (null == prefix) {
+            prefix = "tempDir";
+        }
+        File tempFile = null;
+        for (int i = 0; i < 10; i++) {
+            try {
+                tempFile =  File.createTempFile(prefix,"tmp");       
+                tempFile.delete();
+                if (tempFile.mkdirs()) {
+                    break;
+                }
+                tempFile = null;
+            } catch (IOException e) {
+            }
+        }
+        return tempFile;        
+    }
+
+}
+
diff --git a/build/src/org/aspectj/internal/tools/build/package.html b/build/src/org/aspectj/internal/tools/build/package.html
new file mode 100644
index 000000000..3fa443812
--- /dev/null
+++ b/build/src/org/aspectj/internal/tools/build/package.html
@@ -0,0 +1,12 @@
+<html>
+<!-- todo
+- backed off on doing product installer builds directly;
+  the one installer is now built using Ant.
+  
+- 
+-->
+<body>
+The build taskdef relies on the classes in this package for
+behavior independent of Ant.
+</body>
+</html>