/hg/release/icedtea6-1.6: 2009-09-10 Andrew Haley <aph at redhat....
aph at icedtea.classpath.org
aph at icedtea.classpath.org
Thu Sep 10 05:49:04 PDT 2009
changeset da4268686a33 in /hg/release/icedtea6-1.6
details: http://icedtea.classpath.org/hg/release/icedtea6-1.6?cmd=changeset;node=da4268686a33
author: aph
date: Thu Sep 10 13:52:13 2009 +0100
2009-09-10 Andrew Haley <aph at redhat.com>
* Makefile.am, patches/icedtea-jar-misc.patch: Import patch
from upstream OpenJDK 6.
http://hg.openjdk.java.net/jdk6/jdk6/jdk/rev/b35f1e5075a4
diffstat:
3 files changed, 1134 insertions(+), 1 deletion(-)
ChangeLog | 6
Makefile.am | 3
patches/icedtea-jar-misc.patch | 1126 ++++++++++++++++++++++++++++++++++++++++
diffs (truncated from 1156 to 500 lines):
diff -r d6379c90d5fe -r da4268686a33 ChangeLog
--- a/ChangeLog Wed Sep 09 16:44:37 2009 +0100
+++ b/ChangeLog Thu Sep 10 13:52:13 2009 +0100
@@ -1,3 +1,9 @@ 2009-09-09 Andrew Haley <aph at redhat.co
+2009-09-10 Andrew Haley <aph at redhat.com>
+
+ * Makefile.am, patches/icedtea-jar-misc.patch: Import patch from
+ upstream OpenJDK 6.
+ http://hg.openjdk.java.net/jdk6/jdk6/jdk/rev/b35f1e5075a4
+
2009-09-09 Andrew Haley <aph at redhat.com>
* NEWS: Update for 1.6.
diff -r d6379c90d5fe -r da4268686a33 Makefile.am
--- a/Makefile.am Wed Sep 09 16:44:37 2009 +0100
+++ b/Makefile.am Thu Sep 10 13:52:13 2009 +0100
@@ -622,7 +622,8 @@ ICEDTEA_PATCHES = \
patches/security/icedtea-6824440.patch \
patches/security/icedtea-6830335.patch \
patches/security/icedtea-6845701.patch \
- patches/security/icedtea-6813167.patch
+ patches/security/icedtea-6813167.patch \
+ patches/icedtea-jar-misc.patch
if WITH_ALT_HSBUILD
ICEDTEA_PATCHES += \
diff -r d6379c90d5fe -r da4268686a33 patches/icedtea-jar-misc.patch
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/patches/icedtea-jar-misc.patch Thu Sep 10 13:52:13 2009 +0100
@@ -0,0 +1,1126 @@
+
+# HG changeset patch
+# User martin
+# Date 1246913604 25200
+# Node ID b35f1e5075a42030e8624459b13daa45ffc834f8
+# Parent 1661d42b1c09135b77f039e604878f0985d24255
+6854795: Miscellaneous improvements to "jar"
+6834805: Improve jar -C performance
+6332094: "jar t" and "jar x" should use ZipFile, not ZipInputStream
+6496274: jar seems to use more CPU than it should
+Summary: backport jdk7 jar command (remove use of nio2)
+Reviewed-by: sherman, darcy
+
+--- openjdk/jdk/src/share/classes/sun/tools/jar/Main.java Thu Jun 25 17:15:18 2009 -0400
++++ openjdk/jdk/src/share/classes/sun/tools/jar/Main.java Mon Jul 06 13:53:24 2009 -0700
+@@ -32,6 +32,8 @@ import java.util.jar.Manifest;
+ import java.util.jar.Manifest;
+ import java.text.MessageFormat;
+ import sun.misc.JarIndex;
++import static sun.misc.JarIndex.INDEX_NAME;
++import static java.util.jar.JarFile.MANIFEST_NAME;
+
+ /**
+ * This class implements a simple utility for creating files in the JAR
+@@ -46,10 +48,18 @@ class Main {
+ String zname = "";
+ String[] files;
+ String rootjar = null;
+- Hashtable filesTable = new Hashtable();
+- Vector paths = new Vector();
+- Vector v;
+- CRC32 crc32 = new CRC32();
++
++ // An entryName(path)->File map generated during "expand", it helps to
++ // decide whether or not an existing entry in a jar file needs to be
++ // replaced, during the "update" operation.
++ Map<String, File> entryMap = new HashMap<String, File>();
++
++ // All files need to be added/updated.
++ Set<File> entries = new LinkedHashSet<File>();
++
++ // Directories specified by "-C" operation.
++ Set<String> paths = new HashSet<String>();
++
+ /*
+ * cflag: create
+ * uflag: update
+@@ -62,11 +72,8 @@ class Main {
+ */
+ boolean cflag, uflag, xflag, tflag, vflag, flag0, Mflag, iflag;
+
+- static final String MANIFEST = JarFile.MANIFEST_NAME;
+ static final String MANIFEST_DIR = "META-INF/";
+ static final String VERSION = "1.0";
+- static final char SEPARATOR = File.separatorChar;
+- static final String INDEX = JarIndex.INDEX_NAME;
+
+ private static ResourceBundle rsrc;
+
+@@ -118,9 +125,21 @@ class Main {
+ this.program = program;
+ }
+
++ /**
++ * Creates a new empty temporary file in the same directory as the
++ * specified file. A variant of File.createTempFile.
++ */
++ private static File createTempFileInSameDirectoryAs(File file)
++ throws IOException {
++ File dir = file.getParentFile();
++ if (dir == null)
++ dir = new File(".");
++ return File.createTempFile("jartmp", null, dir);
++ }
++
+ private boolean ok;
+
+- /*
++ /**
+ * Starts main program with the specified arguments.
+ */
+ public synchronized boolean run(String args[]) {
+@@ -153,7 +172,7 @@ class Main {
+ }
+ addVersion(manifest);
+ addCreatedBy(manifest);
+- if (isAmbigousMainClass(manifest)) {
++ if (isAmbiguousMainClass(manifest)) {
+ if (in != null) {
+ in.close();
+ }
+@@ -175,7 +194,8 @@ class Main {
+ vflag = false;
+ }
+ }
+- create(new BufferedOutputStream(out), expand(files), manifest);
++ expand(null, files, false);
++ create(new BufferedOutputStream(out, 4096), manifest);
+ if (in != null) {
+ in.close();
+ }
+@@ -186,9 +206,7 @@ class Main {
+ FileOutputStream out;
+ if (fname != null) {
+ inputFile = new File(fname);
+- String path = inputFile.getParent();
+- tmpFile = File.createTempFile("tmp", null,
+- new File((path == null) ? "." : path));
++ tmpFile = createTempFileInSameDirectoryAs(inputFile);
+ in = new FileInputStream(inputFile);
+ out = new FileOutputStream(tmpFile);
+ } else {
+@@ -198,8 +216,9 @@ class Main {
+ }
+ InputStream manifest = (!Mflag && (mname != null)) ?
+ (new FileInputStream(mname)) : null;
+- expand(files);
+- boolean updateOk = update(in, new BufferedOutputStream(out), manifest);
++ expand(null, files, true);
++ boolean updateOk = update(in, new BufferedOutputStream(out),
++ manifest, null);
+ if (ok) {
+ ok = updateOk;
+ }
+@@ -217,19 +236,32 @@ class Main {
+ }
+ tmpFile.delete();
+ }
+- } else if (xflag || tflag) {
+- InputStream in;
++ } else if (tflag) {
++ replaceFSC(files);
+ if (fname != null) {
+- in = new FileInputStream(fname);
++ list(fname, files);
+ } else {
+- in = new FileInputStream(FileDescriptor.in);
+- }
+- if (xflag) {
+- extract(new BufferedInputStream(in), files);
++ InputStream in = new FileInputStream(FileDescriptor.in);
++ try{
++ list(new BufferedInputStream(in), files);
++ } finally {
++ in.close();
++ }
++ }
++ } else if (xflag) {
++ replaceFSC(files);
++ if (fname != null && files != null) {
++ extract(fname, files);
+ } else {
+- list(new BufferedInputStream(in), files);
+- }
+- in.close();
++ InputStream in = (fname == null)
++ ? new FileInputStream(FileDescriptor.in)
++ : new FileInputStream(fname);
++ try {
++ extract(new BufferedInputStream(in), files);
++ } finally {
++ in.close();
++ }
++ }
+ } else if (iflag) {
+ genIndex(rootjar, files);
+ }
+@@ -248,8 +280,8 @@ class Main {
+ return ok;
+ }
+
+- /*
+- * Parse command line arguments.
++ /**
++ * Parses command line arguments.
+ */
+ boolean parseArgs(String args[]) {
+ /* Preprocess and expand @file arguments */
+@@ -354,7 +386,7 @@ class Main {
+ while (dir.indexOf("//") > -1) {
+ dir = dir.replace("//", "/");
+ }
+- paths.addElement(dir.replace(File.separatorChar, '/'));
++ paths.add(dir.replace(File.separatorChar, '/'));
+ nameBuf[k++] = dir + args[++i];
+ } else {
+ nameBuf[k++] = args[i];
+@@ -383,21 +415,11 @@ class Main {
+ return true;
+ }
+
+- /*
++ /**
+ * Expands list of files to process into full list of all files that
+ * can be found by recursively descending directories.
+ */
+- 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) {
++ void expand(File dir, String[] files, boolean isUpdate) {
+ if (files == null) {
+ return;
+ }
+@@ -409,17 +431,20 @@ class Main {
+ f = new File(dir, files[i]);
+ }
+ if (f.isFile()) {
+- if (!t.contains(f)) {
+- t.put(entryName(f.getPath()), f);
+- v.addElement(f);
++ if (entries.add(f)) {
++ if (isUpdate)
++ entryMap.put(entryName(f.getPath()), 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);
++ if (entries.add(f)) {
++ if (isUpdate) {
++ String dirPath = f.getPath();
++ dirPath = (dirPath.endsWith(File.separator)) ? dirPath :
++ (dirPath + File.separator);
++ entryMap.put(entryName(dirPath), f);
++ }
++ expand(f, f.list(), isUpdate);
++ }
+ } else {
+ error(formatMsg("error.nosuch.fileordir", String.valueOf(f)));
+ ok = false;
+@@ -427,10 +452,10 @@ class Main {
+ }
+ }
+
+- /*
++ /**
+ * Creates a new JAR file.
+ */
+- void create(OutputStream out, String[] files, Manifest manifest)
++ void create(OutputStream out, Manifest manifest)
+ throws IOException
+ {
+ ZipOutputStream zos = new JarOutputStream(out);
+@@ -446,7 +471,7 @@ class Main {
+ e.setSize(0);
+ e.setCrc(0);
+ zos.putNextEntry(e);
+- e = new ZipEntry(MANIFEST);
++ e = new ZipEntry(MANIFEST_NAME);
+ e.setTime(System.currentTimeMillis());
+ if (flag0) {
+ crc32Manifest(e, manifest);
+@@ -455,42 +480,61 @@ class Main {
+ manifest.write(zos);
+ zos.closeEntry();
+ }
+- for (int i = 0; i < files.length; i++) {
+- addFile(zos, new File(files[i]));
++ for (File file: entries) {
++ addFile(zos, file);
+ }
+ zos.close();
+ }
+
+- /*
+- * update an existing jar file.
++ private char toUpperCaseASCII(char c) {
++ return (c < 'a' || c > 'z') ? c : (char) (c + 'A' - 'a');
++ }
++
++ /**
++ * Compares two strings for equality, ignoring case. The second
++ * argument must contain only upper-case ASCII characters.
++ * We don't want case comparison to be locale-dependent (else we
++ * have the notorious "turkish i bug").
++ */
++ private boolean equalsIgnoreCase(String s, String upper) {
++ assert upper.toUpperCase(java.util.Locale.ENGLISH).equals(upper);
++ int len;
++ if ((len = s.length()) != upper.length())
++ return false;
++ for (int i = 0; i < len; i++) {
++ char c1 = s.charAt(i);
++ char c2 = upper.charAt(i);
++ if (c1 != c2 && toUpperCaseASCII(c1) != c2)
++ return false;
++ }
++ return true;
++ }
++
++ /**
++ * Updates an existing jar file.
+ */
+ boolean update(InputStream in, OutputStream out,
+- InputStream newManifest) throws IOException
++ InputStream newManifest,
++ JarIndex jarIndex) 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);
++ if (jarIndex != null) {
++ addIndex(jarIndex, 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)) {
++ boolean isManifestEntry = equalsIgnoreCase(name, MANIFEST_NAME);
++
++ if ((jarIndex != null && equalsIgnoreCase(name, INDEX_NAME))
++ || (Mflag && isManifestEntry)) {
+ continue;
+ } else if (isManifestEntry && ((newManifest != null) ||
+ (ename != null))) {
+@@ -500,9 +544,9 @@ class Main {
+ // 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));
++ boolean ambiguous = isAmbiguousMainClass(new Manifest(fis));
+ fis.close();
+- if (ambigous) {
++ if (ambiguous) {
+ return false;
+ }
+ }
+@@ -514,8 +558,7 @@ class Main {
+ }
+ updateManifest(old, zos);
+ } else {
+- if (!t.containsKey(name)) { // copy the old stuff
+-
++ if (!entryMap.containsKey(name)) { // copy the old stuff
+ // do our own compression
+ ZipEntry e2 = new ZipEntry(name);
+ e2.setMethod(e.getMethod());
+@@ -527,30 +570,24 @@ class Main {
+ e2.setCrc(e.getCrc());
+ }
+ zos.putNextEntry(e2);
+- while ((n = zis.read(buf, 0, buf.length)) != -1) {
+- zos.write(buf, 0, n);
+- }
++ copy(zis, zos);
+ } else { // replace with the new files
+- addFile(zos, (File)(t.get(name)));
+- t.remove(name);
+- }
+- }
+- }
+- t.remove(INDEX);
++ File f = entryMap.get(name);
++ addFile(zos, f);
++ entryMap.remove(name);
++ entries.remove(f);
++ }
++ }
++ }
+
+ // 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);
+- }
+- }
++ for (File f: entries) {
++ addFile(zos, f);
+ }
+ if (!foundManifest) {
+ if (newManifest != null) {
+ Manifest m = new Manifest(newManifest);
+- updateOk = !isAmbigousMainClass(m);
++ updateOk = !isAmbiguousMainClass(m);
+ if (updateOk) {
+ updateManifest(m, zos);
+ }
+@@ -567,23 +604,16 @@ class Main {
+ private void addIndex(JarIndex index, ZipOutputStream zos)
+ throws IOException
+ {
+- ZipEntry e = new ZipEntry(INDEX);
++ ZipEntry e = new ZipEntry(INDEX_NAME);
+ e.setTime(System.currentTimeMillis());
+ if (flag0) {
+- e.setMethod(ZipEntry.STORED);
+- File ifile = File.createTempFile("index", null, new File("."));
+- BufferedOutputStream bos = new BufferedOutputStream
+- (new FileOutputStream(ifile));
+- index.write(bos);
+- crc32File(e, ifile);
+- bos.close();
+- ifile.delete();
++ CRC32OutputStream os = new CRC32OutputStream();
++ index.write(os);
++ os.updateEntry(e);
+ }
+ zos.putNextEntry(e);
+ index.write(zos);
+- if (vflag) {
+- // output(getMsg("out.update.manifest"));
+- }
++ zos.closeEntry();
+ }
+
+ private void updateManifest(Manifest m, ZipOutputStream zos)
+@@ -594,10 +624,9 @@ class Main {
+ if (ename != null) {
+ addMainClass(m, ename);
+ }
+- ZipEntry e = new ZipEntry(MANIFEST);
++ ZipEntry e = new ZipEntry(MANIFEST_NAME);
+ e.setTime(System.currentTimeMillis());
+ if (flag0) {
+- e.setMethod(ZipEntry.STORED);
+ crc32Manifest(e, m);
+ }
+ zos.putNextEntry(e);
+@@ -611,9 +640,9 @@ class Main {
+ private String entryName(String name) {
+ name = name.replace(File.separatorChar, '/');
+ String matchPath = "";
+- for (int i = 0; i < paths.size(); i++) {
+- String path = (String)paths.elementAt(i);
+- if (name.startsWith(path) && (path.length() > matchPath.length())) {
++ for (String path : paths) {
++ if (name.startsWith(path)
++ && (path.length() > matchPath.length())) {
+ matchPath = path;
+ }
+ }
+@@ -651,7 +680,7 @@ class Main {
+ global.put(Attributes.Name.MAIN_CLASS, mainApp);
+ }
+
+- private boolean isAmbigousMainClass(Manifest m) {
++ private boolean isAmbiguousMainClass(Manifest m) {
+ if (ename != null) {
+ Attributes global = m.getMainAttributes();
+ if ((global.get(Attributes.Name.MAIN_CLASS) != null)) {
+@@ -663,13 +692,12 @@ class Main {
More information about the distro-pkg-dev
mailing list