public Main(PrintStream out,
    PrintStream err,
    String program) 
{
        this.out = out;
        this.err = err;
        this.program = program;
}

  void addFile(ZipOutputStream zos,
    File file) throws IOException 
{
        String name = file.getPath();
        boolean isDir = file.isDirectory();
        if (isDir) {
            name = name.endsWith(File.separator) ? name :
                (name + File.separator);
        }
        name = entryName(name);
        if (name.equals("") || name.equals(".") || name.equals(zname)) {
            return;
        } else if ((name.equals(MANIFEST_DIR) || name.equals(MANIFEST))
                   && !Mflag) {
            if (vflag) {
                output(formatMsg("out.ignore.entry", name));
            }
            return;
        }
        long size = isDir ? 0 : file.length();
        if (vflag) {
            out.print(formatMsg("out.adding", name));
        }
        ZipEntry e = new ZipEntry(name);
        e.setTime(file.lastModified());
        if (size == 0) {
            e.setMethod(ZipEntry.STORED);
            e.setSize(0);
            e.setCrc(0);
        } else if (flag0) {
            e.setSize(size);
            e.setMethod(ZipEntry.STORED);
            crc32File(e, file);
        }
        zos.putNextEntry(e);
        if (!isDir) {
            byte[] buf = new byte[1024];
            int len;
            InputStream is = new BufferedInputStream(new FileInputStream(file));
            while ((len = is.read(buf, 0, buf.length)) != -1) {
                zos.write(buf, 0, len);
            }
            is.close();
        }
        zos.closeEntry();
        /* report how much compression occurred. */
        if (vflag) {
            size = e.getSize();
            long csize = e.getCompressedSize();
            out.print(formatMsg2("out.size", String.valueOf(size),
                        String.valueOf(csize)));
            if (e.getMethod() == ZipEntry.DEFLATED) {
                long ratio = 0;
                if (size != 0) {
                    ratio = ((size - csize) * 100) / size;
                }
                output(formatMsg("out.deflated", String.valueOf(ratio)));
            } else {
                output(getMsg("out.stored"));
            }
        }
}

  void create(OutputStream out,
    String[] files,
    Manifest manifest) throws IOException 
{
        ZipOutputStream zos = new JarOutputStream(out);
        if (flag0) {
            zos.setMethod(ZipOutputStream.STORED);
        }
        if (manifest != null) {
            if (vflag) {
                output(getMsg("out.added.manifest"));
            }
            ZipEntry e = new ZipEntry(MANIFEST_DIR);
            e.setTime(System.currentTimeMillis());
            e.setSize(0);
            e.setCrc(0);
            zos.putNextEntry(e);
            e = new ZipEntry(MANIFEST);
            e.setTime(System.currentTimeMillis());
            if (flag0) {
                crc32Manifest(e, manifest);
            }
            zos.putNextEntry(e);
            manifest.write(zos);
            zos.closeEntry();
        }
        for (int i = 0; i <  files.length; i++) {
            addFile(zos, new File(files[i]));
        }
        zos.close();
}

  void dumpIndex(String rootjar,
    JarIndex index) throws IOException 
{
        filesTable.put(INDEX, index);
        File scratchFile = File.createTempFile("scratch", null, new File("."));
        File jarFile = new File(rootjar);
        boolean updateOk = update(new FileInputStream(jarFile),
                new FileOutputStream(scratchFile), null);
        jarFile.delete();
        if (!scratchFile.renameTo(jarFile)) {
            scratchFile.delete();
            throw new IOException(getMsg("error.write.file"));
        }
        scratchFile.delete();
}

Output the class index table to the INDEX.LIST file of the root jar file.

 protected  void error(String s) 
{
        err.println(s);
}

Print an error mesage; like something is broken

 String[] expand(String[] files) 
{
        v = new Vector();
        expand(null, files, v, filesTable);
        files = new String[v.size()];
        for (int i = 0; i <  files.length; i++) {
            files[i] = ((File)v.elementAt(i)).getPath();
        }
        return files;
}

  void expand(File dir,
    String[] files,
    Vector v,
    Hashtable t) 
{
        if (files == null) {
            return;
        }
        for (int i = 0; i <  files.length; i++) {
            File f;
            if (dir == null) {
                f = new File(files[i]);
            } else {
                f = new File(dir, files[i]);
            }
            if (f.isFile()) {
                if (!t.contains(f)) {
                    t.put(entryName(f.getPath()), f);
                    v.addElement(f);
                }
            } else if (f.isDirectory()) {
                String dirPath = f.getPath();
                dirPath = (dirPath.endsWith(File.separator)) ? dirPath :
                    (dirPath + File.separator);
                t.put(entryName(dirPath), f);
                v.addElement(f);
                expand(f, f.list(), v, t);
            } else {
                error(formatMsg("error.nosuch.fileordir", String.valueOf(f)));
                ok = false;
            }
        }
}

  void extract(InputStream in,
    String[] files) throws IOException 
{
        ZipInputStream zis = new ZipInputStream(in);
        ZipEntry e;
        // Set of all directory entries specified in archive.  Dissallows
        // null entries.  Disallows all entries if using pre-6.0 behavior.
        Set< ZipEntry > dirs = new HashSet< ZipEntry >() {
            public boolean add(ZipEntry e) {
                return ((e == null || useExtractionTime) ? false : super.add(e));
            }};
        while ((e = zis.getNextEntry()) != null) {
            if (files == null) {
                dirs.add(extractFile(zis, e));
            } else {
                String name = e.getName();
                for (int i = 0; i <  files.length; i++) {
                    String file = files[i].replace(File.separatorChar, '/");
                    if (name.startsWith(file)) {
                        dirs.add(extractFile(zis, e));
                        break;
                    }
                }
            }
        }
        // Update timestamps of directories specified in archive with their
        // timestamps as given in the archive.  We do this after extraction,
        // instead of during, because creating a file in a directory changes
        // that directory's timestamp.
        for (ZipEntry dirEntry : dirs) {
            long lastModified = dirEntry.getTime();
            if (lastModified != -1) {
                File dir = new File(dirEntry.getName().replace('/", File.separatorChar));
                dir.setLastModified(lastModified);
            }
        }
}

 ZipEntry extractFile(ZipInputStream zis,
    ZipEntry e) throws IOException 
{
        ZipEntry rc = null;
        String name = e.getName();
        File f = new File(e.getName().replace('/", File.separatorChar));
        if (e.isDirectory()) {
            if (f.exists()) {
                if (!f.isDirectory()) {
                    throw new IOException(formatMsg("error.create.dir",
                        f.getPath()));
                }
            } else {
                if (!f.mkdirs()) {
                    throw new IOException(formatMsg("error.create.dir",
                        f.getPath()));
                } else {
                    rc = e;
                }
            }
            if (vflag) {
                output(formatMsg("out.create", name));
            }
        } else {
            if (f.getParent() != null) {
                File d = new File(f.getParent());
                if (!d.exists() && !d.mkdirs() || !d.isDirectory()) {
                    throw new IOException(formatMsg(
                        "error.create.dir", d.getPath()));
                }
            }
            OutputStream os = new FileOutputStream(f);
            byte[] b = new byte[512];
            int len;
            while ((len = zis.read(b, 0, b.length)) != -1) {
                os.write(b, 0, len);
            }
            zis.closeEntry();
            os.close();
            if (vflag) {
                if (e.getMethod() == ZipEntry.DEFLATED) {
                    output(formatMsg("out.inflated", name));
                } else {
                    output(formatMsg("out.extracted", name));
                }
            }
        }
        if (!useExtractionTime) {
            long lastModified = e.getTime();
            if (lastModified != -1) {
                f.setLastModified(lastModified);
            }
        }
        return rc;
}

  void fatalError(Exception e) 
{
        e.printStackTrace();
}

  void fatalError(String s) 
{
        error(program + ": " + s);
}

  void genIndex(String rootjar,
    String[] files) throws IOException 
{
        Vector jars = getJarPath(rootjar);
        int njars = jars.size();
        String[] jarfiles;
        if (njars == 1 && files != null) {
            // no class-path attribute defined in rootjar, will
            // use command line specified list of jars
            for (int i = 0; i <  files.length; i++) {
                jars.addAll(getJarPath(files[i]));
            }
            njars = jars.size();
        }
        jarfiles = (String[])jars.toArray(new String[njars]);
        JarIndex index = new JarIndex(jarfiles);
        dumpIndex(rootjar, index);
}

Generate class index file for the specified root jar file.

 Vector getJarPath(String jar) throws IOException 
{
    /*
     * Generate the transitive closure of the Class-Path attribute for
     * the specified jar file.
     */
        Vector files = new Vector();
        files.add(jar);
        jarTable.put(jar, jar);
        // take out the current path
        String path = jar.substring(0, Math.max(0, jar.lastIndexOf('/") + 1));
        // class path attribute will give us jar file name with
        // '/' as separators, so we need to change them to the
        // appropriate one before we open the jar file.
        JarFile rf = new JarFile(jar.replace('/", File.separatorChar));
        if (rf != null) {
            Manifest man = rf.getManifest();
            if (man != null) {
                Attributes attr = man.getMainAttributes();
                if (attr != null) {
                    String value = attr.getValue(Attributes.Name.CLASS_PATH);
                    if (value != null) {
                        StringTokenizer st = new StringTokenizer(value);
                        while (st.hasMoreTokens()) {
                            String ajar = st.nextToken();
                            if (!ajar.endsWith("/")) {  // it is a jar file
                                ajar = path.concat(ajar);
                                /* check on cyclic dependency */
                                if (jarTable.get(ajar) == null) {
                                    files.addAll(getJarPath(ajar));
                                }
                            }
                        }
                    }
                }
            }
        }
        rf.close();
        return files;
}

  void list(InputStream in,
    String[] files) throws IOException 
{
        ZipInputStream zis = new ZipInputStream(in);
        ZipEntry e;
        while ((e = zis.getNextEntry()) != null) {
            String name = e.getName();
            /*
             * In the case of a compressed (deflated) entry, the entry size
             * is stored immediately following the entry data and cannot be
             * determined until the entry is fully read. Therefore, we close
             * the entry first before printing out its attributes.
             */
            zis.closeEntry();
            if (files == null) {
                printEntry(e);
            } else {
                for (int i = 0; i <  files.length; i++) {
                    String file = files[i].replace(File.separatorChar, '/");
                    if (name.startsWith(file)) {
                        printEntry(e);
                        break;
                    }
                }
            }
        }
}

 public static  void main(String[] args) 
{
        Main jartool = new Main(System.out, System.err, "jar");
        System.exit(jartool.run(args) ? 0 : 1);
}

 protected  void output(String s) 
{
        out.println(s);
}

Print an output message; like verbose output and the like

 boolean parseArgs(String[] args) 
{
        /* Preprocess and expand @file arguments */
        try {
            args = CommandLine.parse(args);
        } catch (FileNotFoundException e) {
            fatalError(formatMsg("error.cant.open", e.getMessage()));
            return false;
        } catch (IOException e) {
            fatalError(e);
            return false;
        }
        /* parse flags */
        int count = 1;
        try {
            String flags = args[0];
            if (flags.startsWith("-")) {
                flags = flags.substring(1);
            }
            for (int i = 0; i <  flags.length(); i++) {
                switch (flags.charAt(i)) {
                case 'c":
                    if (xflag || tflag || uflag) {
                        usageError();
                        return false;
                    }
                    cflag = true;
                    break;
                case 'u":
                    if (cflag || xflag || tflag) {
                        usageError();
                        return false;
                    }
                    uflag = true;
                    break;
                case 'x":
                    if (cflag || uflag || tflag) {
                        usageError();
                        return false;
                    }
                    xflag = true;
                    break;
                case 't":
                    if (cflag || uflag || xflag) {
                        usageError();
                        return false;
                    }
                    tflag = true;
                    break;
                case 'M":
                    Mflag = true;
                    break;
                case 'v":
                    vflag = true;
                    break;
                case 'f":
                    fname = args[count++];
                    break;
                case 'm":
                    mname = args[count++];
                    break;
                case '0":
                    flag0 = true;
                    break;
                case 'i":
                    // do not increase the counter, files will contain rootjar
                    rootjar = args[count++];
                    iflag = true;
                    break;
                case 'e":
                     ename = args[count++];
                     break;
                default:
                    error(formatMsg("error.illegal.option",
                                String.valueOf(flags.charAt(i))));
                    usageError();
                    return false;
                }
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            usageError();
            return false;
        }
        if (!cflag && !tflag && !xflag && !uflag && !iflag) {
            error(getMsg("error.bad.option"));
            usageError();
            return false;
        }
        /* parse file arguments */
        int n = args.length - count;
        if (n  > 0) {
            int k = 0;
            String[] nameBuf = new String[n];
            try {
                for (int i = count; i <  args.length; i++) {
                    if (args[i].equals("-C")) {
                        /* change the directory */
                        String dir = args[++i];
                        dir = (dir.endsWith(File.separator) ?
                               dir : (dir + File.separator));
                        dir = dir.replace(File.separatorChar, '/");
                        while (dir.indexOf("//")  > -1) {
                            dir = dir.replace("//", "/");
                        }
                        paths.addElement(dir.replace(File.separatorChar, '/"));
                        nameBuf[k++] = dir + args[++i];
                    } else {
                        nameBuf[k++] = args[i];
                    }
                }
            } catch (ArrayIndexOutOfBoundsException e) {
                usageError();
                return false;
            }
            files = new String[k];
            System.arraycopy(nameBuf, 0, files, 0, k);
        } else if (cflag && (mname == null)) {
            error(getMsg("error.bad.cflag"));
            usageError();
            return false;
        } else if (uflag) {
            if ((mname != null) || (ename != null)) {
                /* just want to update the manifest */
                return true;
            } else {
                error(getMsg("error.bad.uflag"));
                usageError();
                return false;
            }
        }
        return true;
}

  void printEntry(ZipEntry e) throws IOException 
{
        if (vflag) {
            StringBuffer sb = new StringBuffer();
            String s = Long.toString(e.getSize());
            for (int i = 6 - s.length(); i  > 0; --i) {
                sb.append(' ");
            }
            sb.append(s).append(' ").append(new Date(e.getTime()).toString());
            sb.append(' ").append(e.getName());
            output(sb.toString());
        } else {
            output(e.getName());
        }
}

 public synchronized boolean run(String[] args) 
{
        ok = true;
        if (!parseArgs(args)) {
            return false;
        }
        try {
            if (cflag || uflag) {
                if (fname != null) {
                    // The name of the zip file as it would appear as its own
                    // zip file entry. We use this to make sure that we don't
                    // add the zip file to itself.
                    zname = fname.replace(File.separatorChar, '/");
                    if (zname.startsWith("./")) {
                        zname = zname.substring(2);
                    }
                }
            }
            if (cflag) {
                Manifest manifest = null;
                InputStream in = null;
                if (!Mflag) {
                    if (mname != null) {
                        in = new FileInputStream(mname);
                        manifest = new Manifest(new BufferedInputStream(in));
                    } else {
                        manifest = new Manifest();
                    }
                    addVersion(manifest);
                    addCreatedBy(manifest);
                    if (isAmbigousMainClass(manifest)) {
                        if (in != null) {
                            in.close();
                        }
                        return false;
                    }
                    if (ename != null) {
                        addMainClass(manifest, ename);
                    }
                }
                OutputStream out;
                if (fname != null) {
                    out = new FileOutputStream(fname);
                } else {
                    out = new FileOutputStream(FileDescriptor.out);
                    if (vflag) {
                        // Disable verbose output so that it does not appear
                        // on stdout along with file data
                        // error("Warning: -v option ignored");
                        vflag = false;
                    }
                }
                create(new BufferedOutputStream(out), expand(files), manifest);
                if (in != null) {
                    in.close();
                }
                out.close();
            } else if (uflag) {
                File inputFile = null, tmpFile = null;
                FileInputStream in;
                FileOutputStream out;
                if (fname != null) {
                    inputFile = new File(fname);
                    String path = inputFile.getParent();
                    tmpFile = File.createTempFile("tmp", null,
                              new File((path == null) ? "." : path));
                    in = new FileInputStream(inputFile);
                    out = new FileOutputStream(tmpFile);
                } else {
                    in = new FileInputStream(FileDescriptor.in);
                    out = new FileOutputStream(FileDescriptor.out);
                    vflag = false;
                }
                InputStream manifest = (!Mflag && (mname != null)) ?
                    (new FileInputStream(mname)) : null;
                expand(files);
                boolean updateOk = update(in, new BufferedOutputStream(out), manifest);
                if (ok) {
                    ok = updateOk;
                }
                in.close();
                out.close();
                if (manifest != null) {
                    manifest.close();
                }
                if (fname != null) {
                    // on Win32, we need this delete
                    inputFile.delete();
                    if (!tmpFile.renameTo(inputFile)) {
                        tmpFile.delete();
                        throw new IOException(getMsg("error.write.file"));
                    }
                    tmpFile.delete();
                }
            } else if (xflag || tflag) {
                InputStream in;
                if (fname != null) {
                    in = new FileInputStream(fname);
                } else {
                    in = new FileInputStream(FileDescriptor.in);
                }
                if (xflag) {
                    extract(new BufferedInputStream(in), files);
                } else {
                    list(new BufferedInputStream(in), files);
                }
                in.close();
            } else if (iflag) {
                genIndex(rootjar, files);
            }
        } catch (IOException e) {
            fatalError(e);
            ok = false;
        } catch (Error ee) {
            ee.printStackTrace();
            ok = false;
        } catch (Throwable t) {
            t.printStackTrace();
            ok = false;
        }
        out.flush();
        err.flush();
        return ok;
}

 boolean update(InputStream in,
    OutputStream out,
    InputStream newManifest) throws IOException 
{
        Hashtable t = filesTable;
        Vector v = this.v;
        ZipInputStream zis = new ZipInputStream(in);
        ZipOutputStream zos = new JarOutputStream(out);
        ZipEntry e = null;
        boolean foundManifest = false;
        byte[] buf = new byte[1024];
        int n = 0;
        boolean updateOk = true;
        if (t.containsKey(INDEX)) {
            addIndex((JarIndex)t.get(INDEX), zos);
        }
        // put the old entries first, replace if necessary
        while ((e = zis.getNextEntry()) != null) {
            String name = e.getName();
            boolean isManifestEntry = name.toUpperCase(
                                            java.util.Locale.ENGLISH).
                                        equals(MANIFEST);
            if ((name.toUpperCase().equals(INDEX)
                    && t.containsKey(INDEX))
                    || (Mflag && isManifestEntry)) {
                continue;
            } else if (isManifestEntry && ((newManifest != null) ||
                        (ename != null))) {
                foundManifest = true;
                if (newManifest != null) {
                    // Don't read from the newManifest InputStream, as we
                    // might need it below, and we can't re-read the same data
                    // twice.
                    FileInputStream fis = new FileInputStream(mname);
                    boolean ambigous = isAmbigousMainClass(new Manifest(fis));
                    fis.close();
                    if (ambigous) {
                        return false;
                    }
                }
                // Update the manifest.
                Manifest old = new Manifest(zis);
                if (newManifest != null) {
                    old.read(newManifest);
                }
                updateManifest(old, zos);
            } else {
                if (!t.containsKey(name)) { // copy the old stuff
                    // do our own compression
                    ZipEntry e2 = new ZipEntry(name);
                    e2.setMethod(e.getMethod());
                    e2.setTime(e.getTime());
                    e2.setComment(e.getComment());
                    e2.setExtra(e.getExtra());
                    if (e.getMethod() == ZipEntry.STORED) {
                        e2.setSize(e.getSize());
                        e2.setCrc(e.getCrc());
                    }
                    zos.putNextEntry(e2);
                    while ((n = zis.read(buf, 0, buf.length)) != -1) {
                        zos.write(buf, 0, n);
                    }
                } else { // replace with the new files
                    addFile(zos, (File)(t.get(name)));
                    t.remove(name);
                }
            }
        }
        t.remove(INDEX);
        // add the remaining new files
        if (!t.isEmpty()) {
            for (int i = 0; i <  v.size(); i++) {
                File f = (File)v.elementAt(i);
                if (t.containsValue(f)) {
                    addFile(zos, f);
                }
            }
        }
        if (!foundManifest) {
            if (newManifest != null) {
                Manifest m = new Manifest(newManifest);
                updateOk = !isAmbigousMainClass(m);
                if (updateOk) {
                    updateManifest(m, zos);
                }
            } else if (ename != null) {
                updateManifest(new Manifest(), zos);
            }
        }
        zis.close();
        zos.close();
        return updateOk;
}

  void usageError() 
{
        error(getMsg("usage"));
}