sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/io/FilteredDataEntryReader.java

@@ -0,0 +1,90 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.io;
+
+import java.io.IOException;
+
+
+/**
+ * This DataEntryReader delegates to one of two other DataEntryReader instances,
+ * depending on whether the data entry passes through a given data entry filter
+ * or not.
+ *
+ * @author Eric Lafortune
+ */
+public class FilteredDataEntryReader implements DataEntryReader
+{
+    private final DataEntryFilter dataEntryFilter;
+    private final DataEntryReader acceptedDataEntryReader;
+    private final DataEntryReader rejectedDataEntryReader;
+
+
+    /**
+     * Creates a new FilteredDataEntryReader with only a reader for accepted
+     * data entries.
+     * @param dataEntryFilter         the data entry filter.
+     * @param acceptedDataEntryReader the DataEntryReader to which the reading
+     *                                will be delegated if the filter accepts
+     *                                the data entry. May be <code>null</code>.
+     */
+    public FilteredDataEntryReader(DataEntryFilter dataEntryFilter,
+                                   DataEntryReader acceptedDataEntryReader)
+    {
+        this(dataEntryFilter, acceptedDataEntryReader, null);
+    }
+
+
+    /**
+     * Creates a new FilteredDataEntryReader.
+     * @param dataEntryFilter         the data entry filter.
+     * @param acceptedDataEntryReader the DataEntryReader to which the reading
+     *                                will be delegated if the filter accepts
+     *                                the data entry. May be <code>null</code>.
+     * @param rejectedDataEntryReader the DataEntryReader to which the reading
+     *                                will be delegated if the filter does not
+     *                                accept the data entry. May be
+     *                                <code>null</code>.
+     */
+    public FilteredDataEntryReader(DataEntryFilter dataEntryFilter,
+                                   DataEntryReader acceptedDataEntryReader,
+                                   DataEntryReader rejectedDataEntryReader)
+    {
+        this.dataEntryFilter         = dataEntryFilter;
+        this.acceptedDataEntryReader = acceptedDataEntryReader;
+        this.rejectedDataEntryReader = rejectedDataEntryReader;
+    }
+
+
+    // Implementations for DataEntryReader.
+
+    public void read(DataEntry dataEntry)
+    throws IOException
+    {
+        DataEntryReader dataEntryReader = dataEntryFilter.accepts(dataEntry) ?
+            acceptedDataEntryReader :
+            rejectedDataEntryReader;
+
+        if (dataEntryReader != null)
+        {
+            dataEntryReader.read(dataEntry);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/io/FilteredDataEntryWriter.java

@@ -0,0 +1,125 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.io;
+
+import java.io.*;
+
+/**
+ * This DataEntryWriter delegates to one of two other DataEntryWriter instances,
+ * depending on whether the data entry passes through a given data entry filter
+ * or not.
+ *
+ * @author Eric Lafortune
+ */
+public class FilteredDataEntryWriter implements DataEntryWriter
+{
+    private final DataEntryFilter dataEntryFilter;
+    private DataEntryWriter acceptedDataEntryWriter;
+    private DataEntryWriter rejectedDataEntryWriter;
+
+
+    /**
+     * Creates a new FilteredDataEntryWriter with only a writer for accepted
+     * data entries.
+     * @param dataEntryFilter         the data entry filter.
+     * @param acceptedDataEntryWriter the DataEntryWriter to which the writing
+     *                                will be delegated if the filter accepts
+     *                                the data entry. May be <code>null</code>.
+     */
+    public FilteredDataEntryWriter(DataEntryFilter dataEntryFilter,
+                                   DataEntryWriter acceptedDataEntryWriter)
+    {
+        this(dataEntryFilter, acceptedDataEntryWriter, null);
+    }
+
+
+    /**
+     * Creates a new FilteredDataEntryWriter.
+     * @param dataEntryFilter         the data entry filter.
+     * @param acceptedDataEntryWriter the DataEntryWriter to which the writing
+     *                                will be delegated if the filter accepts
+     *                                the data entry. May be <code>null</code>.
+     * @param rejectedDataEntryWriter the DataEntryWriter to which the writing
+     *                                will be delegated if the filter does not
+     *                                accept the data entry. May be
+     *                                <code>null</code>.
+     */
+    public FilteredDataEntryWriter(DataEntryFilter dataEntryFilter,
+                                   DataEntryWriter acceptedDataEntryWriter,
+                                   DataEntryWriter rejectedDataEntryWriter)
+    {
+        this.dataEntryFilter         = dataEntryFilter;
+        this.acceptedDataEntryWriter = acceptedDataEntryWriter;
+        this.rejectedDataEntryWriter = rejectedDataEntryWriter;
+    }
+
+
+    // Implementations for DataEntryWriter.
+
+    public boolean createDirectory(DataEntry dataEntry) throws IOException
+    {
+        // Get the right data entry writer.
+        DataEntryWriter dataEntryWriter = dataEntryFilter.accepts(dataEntry) ?
+            acceptedDataEntryWriter :
+            rejectedDataEntryWriter;
+
+        // Delegate to it, if it's not null.
+        return dataEntryWriter != null &&
+               dataEntryWriter.createDirectory(dataEntry);
+    }
+
+
+    public OutputStream getOutputStream(DataEntry dataEntry) throws IOException
+    {
+        return getOutputStream(dataEntry,  null);
+    }
+
+
+    public OutputStream getOutputStream(DataEntry dataEntry,
+                                        Finisher  finisher) throws IOException
+    {
+        // Get the right data entry writer.
+        DataEntryWriter dataEntryWriter = dataEntryFilter.accepts(dataEntry) ?
+            acceptedDataEntryWriter :
+            rejectedDataEntryWriter;
+
+        // Delegate to it, if it's not null.
+        return dataEntryWriter != null ?
+            dataEntryWriter.getOutputStream(dataEntry, finisher) :
+            null;
+    }
+
+
+    public void close() throws IOException
+    {
+        if (acceptedDataEntryWriter != null)
+        {
+            acceptedDataEntryWriter.close();
+            acceptedDataEntryWriter = null;
+        }
+
+        if (rejectedDataEntryWriter != null)
+        {
+            rejectedDataEntryWriter.close();
+            rejectedDataEntryWriter = null;
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/io/Finisher.java

@@ -0,0 +1,37 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.io;
+
+import java.io.IOException;
+
+/**
+ * This interface specifies a listener that is called to finish an output stream
+ * before it is closed.
+ *
+ * @author Eric Lafortune
+ */
+public interface Finisher
+{
+    /**
+     * Finishes an output stream right before it is closed.
+     */
+    public void finish() throws IOException;
+}

data/lib/proguard4.7/src/proguard/io/JarReader.java

@@ -0,0 +1,75 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.io;
+
+import java.io.IOException;
+import java.util.zip.*;
+
+/**
+ * This DataEntryReader lets a given DataEntryReader read all data entries of
+ * the read jar/war/zip data entries.
+ *
+ * @author Eric Lafortune
+ */
+public class JarReader implements DataEntryReader
+{
+    private final DataEntryReader dataEntryReader;
+
+
+    /**
+     * Creates a new JarReader.
+     */
+    public JarReader(DataEntryReader dataEntryReader)
+    {
+        this.dataEntryReader = dataEntryReader;
+    }
+
+
+    // Implementation for DataEntryReader.
+
+    public void read(DataEntry dataEntry) throws IOException
+    {
+        ZipInputStream zipInputStream = new ZipInputStream(dataEntry.getInputStream());
+
+        try
+        {
+            // Get all entries from the input jar.
+            while (true)
+            {
+                // Can we get another entry?
+                ZipEntry zipEntry = zipInputStream.getNextEntry();
+                if (zipEntry == null)
+                {
+                    break;
+                }
+
+                // Delegate the actual reading to the data entry reader.
+                dataEntryReader.read(new ZipDataEntry(dataEntry,
+                                                      zipEntry,
+                                                      zipInputStream));
+            }
+        }
+        finally
+        {
+            dataEntry.closeInputStream();
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/io/JarWriter.java

@@ -0,0 +1,235 @@
+/*
+ * ProGuard -- shrinking, optimization, obfuscation, and preverification
+ *             of Java bytecode.
+ *
+ * Copyright (c) 2002-2011 Eric Lafortune (eric@graphics.cornell.edu)
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+package proguard.io;
+
+import proguard.classfile.ClassConstants;
+
+import java.io.*;
+import java.util.*;
+import java.util.jar.*;
+import java.util.zip.*;
+
+
+/**
+ * This DataEntryWriter sends data entries to a given jar/zip file.
+ * The manifest and comment properties can optionally be set.
+ *
+ * @author Eric Lafortune
+ */
+public class JarWriter implements DataEntryWriter, Finisher
+{
+    private final DataEntryWriter dataEntryWriter;
+    private final Manifest        manifest;
+    private final String          comment;
+
+    private OutputStream    currentParentOutputStream;
+    private ZipOutputStream currentJarOutputStream;
+    private Finisher        currentFinisher;
+    private DataEntry       currentDataEntry;
+
+    // The names of the jar entries that are already in the jar.
+    private final Set jarEntryNames = new HashSet();
+
+
+    /**
+     * Creates a new JarWriter without manifest or comment.
+     */
+    public JarWriter(DataEntryWriter dataEntryWriter)
+    {
+        this(dataEntryWriter, null, null);
+    }
+
+
+    /**
+     * Creates a new JarWriter.
+     */
+    public JarWriter(DataEntryWriter dataEntryWriter,
+                     Manifest        manifest,
+                     String          comment)
+    {
+        this.dataEntryWriter = dataEntryWriter;
+        this.manifest        = manifest;
+        this.comment         = comment;
+    }
+
+
+    // Implementations for DataEntryWriter.
+
+    public boolean createDirectory(DataEntry dataEntry) throws IOException
+    {
+        //Make sure we can start with a new entry.
+        if (!prepareEntry(dataEntry))
+        {
+            return false;
+        }
+
+        // Close the previous ZIP entry, if any.
+        closeEntry();
+
+        // Get the directory entry name.
+        String name = dataEntry.getName() + ClassConstants.INTERNAL_PACKAGE_SEPARATOR;
+
+        // We have to check if the name is already used, because
+        // ZipOutputStream doesn't handle this case properly (it throws
+        // an exception which can be caught, but the ZipDataEntry is
+        // remembered anyway).
+        if (jarEntryNames.add(name))
+        {
+            // Create a new directory entry.
+            currentJarOutputStream.putNextEntry(new ZipEntry(name));
+            currentJarOutputStream.closeEntry();
+        }
+
+        // Clear the finisher.
+        currentFinisher  = null;
+        currentDataEntry = null;
+
+        return true;
+    }
+
+
+    public OutputStream getOutputStream(DataEntry dataEntry) throws IOException
+    {
+        return getOutputStream(dataEntry,  null);
+    }
+
+
+    public OutputStream getOutputStream(DataEntry dataEntry,
+                                        Finisher  finisher) throws IOException
+    {
+        //Make sure we can start with a new entry.
+        if (!prepareEntry(dataEntry))
+        {
+            return null;
+        }
+
+        // Do we need a new entry?
+        if (!dataEntry.equals(currentDataEntry))
+        {
+            // Close the previous ZIP entry, if any.
+            closeEntry();
+
+            // Get the entry name.
+            String name = dataEntry.getName();
+
+            // We have to check if the name is already used, because
+            // ZipOutputStream doesn't handle this case properly (it throws
+            // an exception which can be caught, but the ZipDataEntry is
+            // remembered anyway).
+            if (!jarEntryNames.add(name))
+            {
+                throw new IOException("Duplicate zip entry ["+dataEntry+"]");
+            }
+
+            // Create a new entry.
+            currentJarOutputStream.putNextEntry(new ZipEntry(name));
+
+            // Set up the finisher for the entry.
+            currentFinisher  = finisher;
+            currentDataEntry = dataEntry;
+        }
+
+        return currentJarOutputStream;
+    }
+
+
+    public void finish() throws IOException
+    {
+        // Finish the entire ZIP stream, if any.
+        if (currentJarOutputStream != null)
+        {
+            // Close the previous ZIP entry, if any.
+            closeEntry();
+
+            // Finish the entire ZIP stream.
+            currentJarOutputStream.finish();
+            currentJarOutputStream    = null;
+            currentParentOutputStream = null;
+            jarEntryNames.clear();
+        }
+    }
+
+
+    public void close() throws IOException
+    {
+        // Close the parent stream.
+        dataEntryWriter.close();
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Makes sure the current output stream is set up for the given entry.
+     */
+    private boolean prepareEntry(DataEntry dataEntry) throws IOException
+    {
+        // Get the parent stream, new or exisiting.
+        // This may finish our own jar output stream.
+        OutputStream parentOutputStream =
+            dataEntryWriter.getOutputStream(dataEntry.getParent(), this);
+
+        // Did we get a stream?
+        if (parentOutputStream == null)
+        {
+            return false;
+        }
+
+        // Do we need a new stream?
+        if (currentParentOutputStream == null)
+        {
+            currentParentOutputStream = parentOutputStream;
+
+            // Create a new jar stream, with a manifest, if set.
+            currentJarOutputStream = manifest != null ?
+                new JarOutputStream(parentOutputStream, manifest) :
+                new ZipOutputStream(parentOutputStream);
+
+            // Add a comment, if set.
+            if (comment != null)
+            {
+                currentJarOutputStream.setComment(comment);
+            }
+        }
+
+        return true;
+    }
+
+
+    /**
+     * Closes the previous ZIP entry, if any.
+     */
+    private void closeEntry() throws IOException
+    {
+        if (currentDataEntry != null)
+        {
+            // Let any finisher finish up first.
+            if (currentFinisher != null)
+            {
+                currentFinisher.finish();
+                currentFinisher = null;
+            }
+
+            currentJarOutputStream.closeEntry();
+            currentDataEntry = null;
+        }
+    }
+}