sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/DataEntryReaderFactory.java

@@ -0,0 +1,141 @@
+/*
+ * 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;
+
+import proguard.io.*;
+import proguard.util.*;
+
+import java.util.List;
+
+
+/**
+ * This class can create DataEntryReader instances based on class path entries.
+ * The readers will unwrap the input data entries from any jars, wars, ears,
+ * and zips, before passing them to a given reader.
+ *
+ * @author Eric Lafortune
+ */
+public class DataEntryReaderFactory
+{
+    /**
+     * Creates a DataEntryReader that can read the given class path entry.
+     *
+     * @param messagePrefix  a prefix for messages that are printed out.
+     * @param classPathEntry the input class path entry.
+     * @param reader         a data entry reader to which the reading of actual
+     *                       classes and resource files can be delegated.
+     * @return a DataEntryReader for reading the given class path entry.
+     */
+    public static DataEntryReader createDataEntryReader(String          messagePrefix,
+                                                        ClassPathEntry  classPathEntry,
+                                                        DataEntryReader reader)
+    {
+        boolean isJar = classPathEntry.isJar();
+        boolean isWar = classPathEntry.isWar();
+        boolean isEar = classPathEntry.isEar();
+        boolean isZip = classPathEntry.isZip();
+
+        List filter    = classPathEntry.getFilter();
+        List jarFilter = classPathEntry.getJarFilter();
+        List warFilter = classPathEntry.getWarFilter();
+        List earFilter = classPathEntry.getEarFilter();
+        List zipFilter = classPathEntry.getZipFilter();
+
+        System.out.println(messagePrefix +
+                           (isJar ? "jar" :
+                            isWar ? "war" :
+                            isEar ? "ear" :
+                            isZip ? "zip" :
+                                    "directory") +
+                           " [" + classPathEntry.getName() + "]" +
+                           (filter    != null ||
+                            jarFilter != null ||
+                            warFilter != null ||
+                            earFilter != null ||
+                            zipFilter != null ? " (filtered)" : ""));
+
+        // Add a filter, if specified.
+        if (filter != null)
+        {
+            reader = new FilteredDataEntryReader(
+                     new DataEntryNameFilter(
+                     new ListParser(new FileNameParser()).parse(filter)),
+                         reader);
+        }
+
+        // Unzip any jars, if necessary.
+        reader = wrapInJarReader(reader, isJar, jarFilter, ".jar");
+        if (!isJar)
+        {
+            // Unzip any wars, if necessary.
+            reader = wrapInJarReader(reader, isWar, warFilter, ".war");
+            if (!isWar)
+            {
+                // Unzip any ears, if necessary.
+                reader = wrapInJarReader(reader, isEar, earFilter, ".ear");
+                if (!isEar)
+                {
+                    // Unzip any zips, if necessary.
+                    reader = wrapInJarReader(reader, isZip, zipFilter, ".zip");
+                }
+            }
+        }
+
+        return reader;
+    }
+
+
+    /**
+     *  Wraps the given DataEntryReader in a JarReader, filtering it if necessary.
+     */
+    private static DataEntryReader wrapInJarReader(DataEntryReader reader,
+                                                   boolean         isJar,
+                                                   List            jarFilter,
+                                                   String          jarExtension)
+    {
+        // Unzip any jars, if necessary.
+        DataEntryReader jarReader = new JarReader(reader);
+
+        if (isJar)
+        {
+            // Always unzip.
+            return jarReader;
+        }
+        else
+        {
+            // Add a filter, if specified.
+            if (jarFilter != null)
+            {
+                jarReader = new FilteredDataEntryReader(
+                            new DataEntryNameFilter(
+                            new ListParser(new FileNameParser()).parse(jarFilter)),
+                                jarReader);
+            }
+
+            // Only unzip the right type of jars.
+            return new FilteredDataEntryReader(
+                   new DataEntryNameFilter(
+                   new ExtensionMatcher(jarExtension)),
+                       jarReader,
+                       reader);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/DataEntryWriterFactory.java

@@ -0,0 +1,150 @@
+/*
+ * 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;
+
+import proguard.io.*;
+import proguard.util.*;
+
+import java.util.List;
+
+/**
+ * This class can create DataEntryWriter instances based on class paths. The
+ * writers will wrap the output in the proper jars, wars, ears, and zips.
+ *
+ * @author Eric Lafortune
+ */
+public class DataEntryWriterFactory
+{
+    /**
+     * Creates a DataEntryWriter that can write to the given class path entries.
+     *
+     * @param classPath the output class path.
+     * @param fromIndex the start index in the class path.
+     * @param toIndex   the end index in the class path.
+     * @return a DataEntryWriter for writing to the given class path entries.
+     */
+    public static DataEntryWriter createDataEntryWriter(ClassPath classPath,
+                                                        int       fromIndex,
+                                                        int       toIndex)
+    {
+        DataEntryWriter writer = null;
+
+        // Create a chain of writers, one for each class path entry.
+        for (int index = toIndex - 1; index >= fromIndex; index--)
+        {
+            ClassPathEntry entry = classPath.get(index);
+            writer = createClassPathEntryWriter(entry, writer);
+        }
+
+        return writer;
+    }
+
+
+    /**
+     * Creates a DataEntryWriter that can write to the given class path entry,
+     * or delegate to another DataEntryWriter if its filters don't match.
+     */
+    private static DataEntryWriter createClassPathEntryWriter(ClassPathEntry  classPathEntry,
+                                                              DataEntryWriter alternativeWriter)
+    {
+        boolean isJar = classPathEntry.isJar();
+        boolean isWar = classPathEntry.isWar();
+        boolean isEar = classPathEntry.isEar();
+        boolean isZip = classPathEntry.isZip();
+
+        List filter    = classPathEntry.getFilter();
+        List jarFilter = classPathEntry.getJarFilter();
+        List warFilter = classPathEntry.getWarFilter();
+        List earFilter = classPathEntry.getEarFilter();
+        List zipFilter = classPathEntry.getZipFilter();
+
+        System.out.println("Preparing output " +
+                           (isJar ? "jar" :
+                            isWar ? "war" :
+                            isEar ? "ear" :
+                            isZip ? "zip" :
+                                    "directory") +
+                           " [" + classPathEntry.getName() + "]" +
+                           (filter    != null ||
+                            jarFilter != null ||
+                            warFilter != null ||
+                            earFilter != null ||
+                            zipFilter != null ? " (filtered)" : ""));
+
+        DataEntryWriter writer = new DirectoryWriter(classPathEntry.getFile(),
+                                                     isJar ||
+                                                     isWar ||
+                                                     isEar ||
+                                                     isZip);
+
+        // Set up the filtered jar writers.
+        writer = wrapInJarWriter(writer, isZip, zipFilter, ".zip", isJar || isWar || isEar);
+        writer = wrapInJarWriter(writer, isEar, earFilter, ".ear", isJar || isWar);
+        writer = wrapInJarWriter(writer, isWar, warFilter, ".war", isJar);
+        writer = wrapInJarWriter(writer, isJar, jarFilter, ".jar", false);
+
+        // Add a filter, if specified.
+        writer = filter != null?
+            new FilteredDataEntryWriter(
+            new DataEntryNameFilter(
+            new ListParser(new FileNameParser()).parse(filter)),
+                writer) :
+            writer;
+
+        // Let the writer cascade, if specified.
+        return alternativeWriter != null ?
+            new CascadingDataEntryWriter(writer, alternativeWriter) :
+            writer;
+    }
+
+
+    /**
+     * Wraps the given DataEntryWriter in a JarWriter, filtering if necessary.
+     */
+    private static DataEntryWriter wrapInJarWriter(DataEntryWriter writer,
+                                                   boolean         isJar,
+                                                   List            jarFilter,
+                                                   String          jarExtension,
+                                                   boolean         dontWrap)
+    {
+        // Zip up jars, if necessary.
+        DataEntryWriter jarWriter = dontWrap ?
+            (DataEntryWriter)new ParentDataEntryWriter(writer) :
+            (DataEntryWriter)new JarWriter(writer);
+
+        // Add a filter, if specified.
+        DataEntryWriter filteredJarWriter = jarFilter != null?
+            new FilteredDataEntryWriter(
+            new DataEntryParentFilter(
+            new DataEntryNameFilter(
+            new ListParser(new FileNameParser()).parse(jarFilter))),
+                 jarWriter) :
+            jarWriter;
+
+        // Only zip up jars, unless the output is a jar file itself.
+        return new FilteredDataEntryWriter(
+               new DataEntryParentFilter(
+               new DataEntryNameFilter(
+               new ExtensionMatcher(jarExtension))),
+                   filteredJarWriter,
+                   isJar ? jarWriter : writer);
+    }
+}

data/lib/proguard4.7/src/proguard/DescriptorKeepChecker.java

@@ -0,0 +1,169 @@
+/*
+ * 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;
+
+import proguard.classfile.*;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.*;
+import proguard.optimize.*;
+
+import java.util.List;
+
+
+/**
+ * This class checks whether classes referenced by class members that are
+ * marked to be kept are marked to be kept too.
+ *
+ * @author Eric Lafortune
+ */
+public class DescriptorKeepChecker
+extends      SimplifiedVisitor
+implements   MemberVisitor,
+             ClassVisitor
+{
+    private final ClassPool      programClassPool;
+    private final ClassPool      libraryClassPool;
+    private final WarningPrinter notePrinter;
+
+    // Some fields acting as parameters for the class visitor.
+    private Clazz   referencingClass;
+    private Member  referencingMember;
+    private boolean isField;
+
+
+    /**
+     * Creates a new DescriptorKeepChecker.
+     */
+    public DescriptorKeepChecker(ClassPool      programClassPool,
+                                 ClassPool      libraryClassPool,
+                                 WarningPrinter notePrinter)
+    {
+        this.programClassPool = programClassPool;
+        this.libraryClassPool = libraryClassPool;
+        this.notePrinter      = notePrinter;
+    }
+
+
+    /**
+     * Checks the classes mentioned in the given keep specifications, printing
+     * notes if necessary.
+     */
+    public void checkClassSpecifications(List keepSpecifications)
+    {
+        // Clean up any old visitor info.
+        programClassPool.classesAccept(new ClassCleaner());
+        libraryClassPool.classesAccept(new ClassCleaner());
+
+        // Create a visitor for marking the seeds.
+        KeepMarker keepMarker = new KeepMarker();
+        ClassPoolVisitor classPoolvisitor =
+            ClassSpecificationVisitorFactory.createClassPoolVisitor(keepSpecifications,
+                                                                    keepMarker,
+                                                                    keepMarker,
+                                                                    false,
+                                                                    true,
+                                                                    true);
+        // Mark the seeds.
+        programClassPool.accept(classPoolvisitor);
+        libraryClassPool.accept(classPoolvisitor);
+
+        // Print out notes about argument types that are not being kept in
+        // class members that are being kept.
+        programClassPool.classesAccept(
+            new AllMemberVisitor(
+            new KeptMemberFilter(this)));
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        //referencingClass  = programClass;
+        //referencingMember = programField;
+        //isField           = true;
+        //
+        // Don't check the type, because it is not required for introspection.
+        //programField.referencedClassesAccept(this);
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        referencingClass  = programClass;
+        referencingMember = programMethod;
+        isField           = false;
+
+        // Don't check the return type, because it is not required for
+        // introspection (e.g. the return type of the special Enum methods).
+        //programMethod.referencedClassesAccept(this);
+
+        Clazz[] referencedClasses = programMethod.referencedClasses;
+        if (referencedClasses != null)
+        {
+            int count = referencedClasses.length;
+
+            // Adapt the count if the return type is a class type (not so
+            // pretty; assuming test just checks for final ';').
+            if (ClassUtil.isInternalClassType(programMethod.getDescriptor(programClass)))
+            {
+                count--;
+            }
+
+            for (int index = 0; index < count; index++)
+            {
+                if (referencedClasses[index] != null)
+                {
+                    referencedClasses[index].accept(this);
+                }
+            }
+        }
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        if (!KeepMarker.isKept(programClass))
+        {
+            notePrinter.print(referencingClass.getName(),
+                              programClass.getName(),
+                              "Note: the configuration keeps the entry point '" +
+                              ClassUtil.externalClassName(referencingClass.getName()) +
+                              " { " +
+                              (isField ?
+                                   ClassUtil.externalFullFieldDescription(0,
+                                                                          referencingMember.getName(referencingClass),
+                                                                          referencingMember.getDescriptor(referencingClass)) :
+                                   ClassUtil.externalFullMethodDescription(referencingClass.getName(),
+                                                                           0,
+                                                                           referencingMember.getName(referencingClass),
+                                                                           referencingMember.getDescriptor(referencingClass))) +
+                              "; }', but not the descriptor class '" +
+                              ClassUtil.externalClassName(programClass.getName()) +
+                              "'");
+        }
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass) {}
+}