/**

/**

     * Create an empty jar file.

     * Build the zip file.

     * @param zipFile the file to create

     * This is called twice if doubleFilePass is true.

     * @return true for historic reasons

     * @throws BuildException on error

     * @throws BuildException on error

     */

     */

    public void executeMain() throws BuildException {

    protected boolean createEmptyZip(File zipFile) throws BuildException {

        if (!createEmpty) {

        if (baseDir == null && resources.size() == 0

            return true;

            && groupfilesets.size() == 0 && "zip".equals(archiveType)) {

        }

            throw new BuildException("basedir attribute must be set, "

                                     + "or at least one "

        if (emptyBehavior.equals("skip")) {

                                     + "resource collection must be given!");

                log("Warning: skipping " + archiveType + " archive "

        }

                    + zipFile + " because no files were included.",

                    Project.MSG_WARN);

        if (zipFile == null) {

                return true;

            throw new BuildException("You must specify the "

        } else if (emptyBehavior.equals("fail")) {

                                     + archiveType + " file to create!");

            throw new BuildException("Cannot create " + archiveType

        }

                                     + " archive " + zipFile

                                     + ": no files were included.",

        if (zipFile.exists() && !zipFile.isFile()) {

                                     getLocation());

            throw new BuildException(zipFile + " is not a file.");

        }

        }

        ZipOutputStream zOut = null;

        if (zipFile.exists() && !zipFile.canWrite()) {

        try {

            throw new BuildException(zipFile + " is read-only.");

            log("Building MANIFEST-only jar: "

        }

                + getDestFile().getAbsolutePath());

            zOut = new ZipOutputStream(new FileOutputStream(getDestFile()));

        // Renamed version of original file, if it exists

        File renamedFile = null;

            zOut.setEncoding(getEncoding());

        addingNewFiles = true;

            if (isCompress()) {

                zOut.setMethod(ZipOutputStream.DEFLATED);

        // Whether or not an actual update is required -

            } else {

        // we don't need to update if the original file doesn't exist

                zOut.setMethod(ZipOutputStream.STORED);

        if (doUpdate && !zipFile.exists()) {

            }

            doUpdate = false;

            initZipOutputStream(zOut);

            log("ignoring update attribute as " + archiveType

            finalizeZipOutputStream(zOut);

                + " doesn't exist.", Project.MSG_DEBUG);

        } catch (IOException ioe) {

        }

            throw new BuildException("Could not create almost empty JAR archive"

                                     + " (" + ioe.getMessage() + ")", ioe,

        // Add the files found in groupfileset to fileset

                                     getLocation());

        for (int i = 0; i < groupfilesets.size(); i++) {

        } finally {

            // Close the output stream.

            log("Processing groupfileset ", Project.MSG_VERBOSE);

            try {

            FileSet fs = (FileSet) groupfilesets.elementAt(i);

                if (zOut != null) {

            FileScanner scanner = fs.getDirectoryScanner(getProject());

                    zOut.close();

            String[] files = scanner.getIncludedFiles();

                }

            File basedir = scanner.getBasedir();

            } catch (IOException ex) {

            for (int j = 0; j < files.length; j++) {

                // Ignore close exception

            }

                log("Adding file " + files[j] + " to fileset",

            createEmpty = false;

                    Project.MSG_VERBOSE);

        }

                ZipFileSet zf = new ZipFileSet();

        return true;

                zf.setProject(getProject());

    }

                zf.setSrc(new File(basedir, files[j]));

                add(zf);

                filesetsFromGroupfilesets.addElement(zf);

            }

        }

        // collect filesets to pass them to getResourcesToAdd

        Vector vfss = new Vector();

        if (baseDir != null) {

            FileSet fs = (FileSet) getImplicitFileSet().clone();

            fs.setDir(baseDir);

            vfss.addElement(fs);

        }

        for (int i = 0; i < resources.size(); i++) {

            ResourceCollection rc = (ResourceCollection) resources.elementAt(i);

            vfss.addElement(rc);

        }

        ResourceCollection[] fss = new ResourceCollection[vfss.size()];

        vfss.copyInto(fss);

        boolean success = false;

        try {

            // can also handle empty archives

            ArchiveState state = getResourcesToAdd(fss, zipFile, false);

            // quick exit if the target is up to date

            if (!state.isOutOfDate()) {

                return;

            }

            if (!zipFile.exists() && state.isWithoutAnyResources()) {

                createEmptyZip(zipFile);

                return;

            }

            Resource[][] addThem = state.getResourcesToAdd();

            if (doUpdate) {

                renamedFile =

                    FILE_UTILS.createTempFile("zip", ".tmp",

                                              zipFile.getParentFile());

                renamedFile.deleteOnExit();

                try {

                    FILE_UTILS.rename(zipFile, renamedFile);

                } catch (SecurityException e) {

                    throw new BuildException(

                        "Not allowed to rename old file ("

                        + zipFile.getAbsolutePath()

                        + ") to temporary file");

                } catch (IOException e) {

                    throw new BuildException(

                        "Unable to rename old file ("

                        + zipFile.getAbsolutePath()

                        + ") to temporary file");

                }

            }

            String action = doUpdate ? "Updating " : "Building ";

            log(action + archiveType + ": " + zipFile.getAbsolutePath());

            ZipOutputStream zOut = null;

            try {

                if (!skipWriting) {

                    zOut = new ZipOutputStream(zipFile);

                    zOut.setEncoding(encoding);

                    zOut.setMethod(doCompress

                        ? ZipOutputStream.DEFLATED : ZipOutputStream.STORED);

                    zOut.setLevel(level);

                }

                initZipOutputStream(zOut);

                // Add the explicit resource collections to the archive.

                for (int i = 0; i < fss.length; i++) {

                    if (addThem[i].length != 0) {

                        addResources(fss[i], addThem[i], zOut);

                    }

                }

                if (doUpdate) {

                    addingNewFiles = false;

                    ZipFileSet oldFiles = new ZipFileSet();

                    oldFiles.setProject(getProject());

                    oldFiles.setSrc(renamedFile);

                    oldFiles.setDefaultexcludes(false);

                    for (int i = 0; i < addedFiles.size(); i++) {

                        PatternSet.NameEntry ne = oldFiles.createExclude();

                        ne.setName((String) addedFiles.elementAt(i));

                    }

                    DirectoryScanner ds =

                        oldFiles.getDirectoryScanner(getProject());

                    ((ZipScanner) ds).setEncoding(encoding);

                    String[] f = ds.getIncludedFiles();

                    Resource[] r = new Resource[f.length];

                    for (int i = 0; i < f.length; i++) {

                        r[i] = ds.getResource(f[i]);

                    }

                    if (!doFilesonly) {

                        String[] d = ds.getIncludedDirectories();

                        Resource[] dr = new Resource[d.length];

                        for (int i = 0; i < d.length; i++) {

                            dr[i] = ds.getResource(d[i]);

                        }

                        Resource[] tmp = r;

                        r = new Resource[tmp.length + dr.length];

                        System.arraycopy(dr, 0, r, 0, dr.length);

                        System.arraycopy(tmp, 0, r, dr.length, tmp.length);

                    }

                    addResources(oldFiles, r, zOut);

                }

                if (zOut != null) {

                    zOut.setComment(comment);

                }

                finalizeZipOutputStream(zOut);

                // If we've been successful on an update, delete the

                // temporary file

                if (doUpdate) {

                    if (!renamedFile.delete()) {

                        log ("Warning: unable to delete temporary file "

                            + renamedFile.getName(), Project.MSG_WARN);

                    }

                }

                success = true;

            } finally {

                // Close the output stream.

                try {

                    if (zOut != null) {

                        zOut.close();

                    }

                } catch (IOException ex) {

                    // If we're in this finally clause because of an

                    // exception, we don't really care if there's an

                    // exception when closing the stream. E.g. if it

                    // throws "ZIP file must have at least one entry",

                    // because an exception happened before we added

                    // any files, then we must swallow this

                    // exception. Otherwise, the error that's reported

                    // will be the close() error, which is not the

                    // real cause of the problem.

                    if (success) {

                        throw ex;

                    }

                }

            }

        } catch (IOException ioe) {

            String msg = "Problem creating " + archiveType + ": "

                + ioe.getMessage();

            // delete a bogus ZIP file (but only if it's not the original one)

            if ((!doUpdate || renamedFile != null) && !zipFile.delete()) {

                msg += " (and the archive is probably corrupt but I could not "

                    + "delete it)";

            }

            if (doUpdate && renamedFile != null) {

                try {

                    FILE_UTILS.rename(renamedFile, zipFile);

                } catch (IOException e) {

                    msg += " (and I couldn't rename the temporary file "

                            + renamedFile.getName() + " back)";

                }

            }

            throw new BuildException(msg, ioe, getLocation());

        } finally {

            cleanUp();

        }

    }