sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/shrink/ShortestUsageMarker.java

@@ -0,0 +1,277 @@
+/*
+ * 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.shrink;
+
+import proguard.classfile.*;
+import proguard.classfile.visitor.*;
+
+
+/**
+ * This ClassVisitor and MemberVisitor recursively marks all classes
+ * and class elements that are being used. For each element, it finds the
+ * shortest chain of dependencies.
+ *
+ * @see ClassShrinker
+ *
+ * @author Eric Lafortune
+ */
+public class ShortestUsageMarker extends UsageMarker
+{
+    private static final ShortestUsageMark INITIAL_MARK =
+        new ShortestUsageMark("is kept by a directive in the configuration.\n\n");
+
+
+    // A field acting as a parameter to the visitor methods.
+    private ShortestUsageMark currentUsageMark = INITIAL_MARK;
+
+    // A utility object to check for recursive causes.
+    private final MyRecursiveCauseChecker recursiveCauseChecker = new MyRecursiveCauseChecker();
+
+
+    // Overriding implementations for UsageMarker.
+
+    protected void markProgramClassBody(ProgramClass programClass)
+    {
+        ShortestUsageMark previousUsageMark = currentUsageMark;
+
+        currentUsageMark = new ShortestUsageMark(getShortestUsageMark(programClass),
+                                                 "is extended by   ",
+                                                 10000,
+                                                 programClass);
+
+        super.markProgramClassBody(programClass);
+
+        currentUsageMark = previousUsageMark;
+    }
+
+
+    protected void markProgramFieldBody(ProgramClass programClass, ProgramField programField)
+    {
+        ShortestUsageMark previousUsageMark = currentUsageMark;
+
+        currentUsageMark = new ShortestUsageMark(getShortestUsageMark(programField),
+                                                 "is referenced by ",
+                                                 1,
+                                                 programClass,
+                                                 programField);
+
+        super.markProgramFieldBody(programClass, programField);
+
+        currentUsageMark = previousUsageMark;
+    }
+
+
+    protected void markProgramMethodBody(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        ShortestUsageMark previousUsageMark = currentUsageMark;
+
+        currentUsageMark = new ShortestUsageMark(getShortestUsageMark(programMethod),
+                                                 "is invoked by    ",
+                                                 1,
+                                                 programClass,
+                                                 programMethod);
+
+        super.markProgramMethodBody(programClass, programMethod);
+
+        currentUsageMark = previousUsageMark;
+    }
+
+
+    protected void markMethodHierarchy(Clazz clazz, Method method)
+    {
+        ShortestUsageMark previousUsageMark = currentUsageMark;
+
+        currentUsageMark = new ShortestUsageMark(getShortestUsageMark(method),
+                                                 "implements       ",
+                                                 100,
+                                                 clazz,
+                                                 method);
+
+        super.markMethodHierarchy(clazz, method);
+
+        currentUsageMark = previousUsageMark;
+    }
+
+
+    // Small utility methods.
+
+    protected void markAsUsed(VisitorAccepter visitorAccepter)
+    {
+        Object visitorInfo = visitorAccepter.getVisitorInfo();
+
+        ShortestUsageMark shortestUsageMark =
+            visitorInfo != null                           &&
+            visitorInfo instanceof ShortestUsageMark      &&
+            !((ShortestUsageMark)visitorInfo).isCertain() &&
+            !currentUsageMark.isShorter((ShortestUsageMark)visitorInfo) ?
+                new ShortestUsageMark((ShortestUsageMark)visitorInfo, true):
+                currentUsageMark;
+
+        visitorAccepter.setVisitorInfo(shortestUsageMark);
+    }
+
+
+    protected boolean shouldBeMarkedAsUsed(VisitorAccepter visitorAccepter)
+    {
+        Object visitorInfo = visitorAccepter.getVisitorInfo();
+
+        return //!(visitorAccepter instanceof Clazz &&
+               //  isCausedBy(currentUsageMark, (Clazz)visitorAccepter)) &&
+               (visitorInfo == null                           ||
+               !(visitorInfo instanceof ShortestUsageMark)   ||
+               !((ShortestUsageMark)visitorInfo).isCertain() ||
+               currentUsageMark.isShorter((ShortestUsageMark)visitorInfo));
+    }
+
+
+    protected boolean isUsed(VisitorAccepter visitorAccepter)
+    {
+        Object visitorInfo = visitorAccepter.getVisitorInfo();
+
+        return visitorInfo != null                      &&
+               visitorInfo instanceof ShortestUsageMark &&
+               ((ShortestUsageMark)visitorInfo).isCertain();
+    }
+
+
+    protected void markAsPossiblyUsed(VisitorAccepter visitorAccepter)
+    {
+        visitorAccepter.setVisitorInfo(new ShortestUsageMark(currentUsageMark, false));
+    }
+
+
+    protected boolean shouldBeMarkedAsPossiblyUsed(VisitorAccepter visitorAccepter)
+    {
+        Object visitorInfo = visitorAccepter.getVisitorInfo();
+
+        return visitorInfo == null                         ||
+               !(visitorInfo instanceof ShortestUsageMark) ||
+               (!((ShortestUsageMark)visitorInfo).isCertain() &&
+                currentUsageMark.isShorter((ShortestUsageMark)visitorInfo));
+    }
+
+
+    protected boolean isPossiblyUsed(VisitorAccepter visitorAccepter)
+    {
+        Object visitorInfo = visitorAccepter.getVisitorInfo();
+
+        return visitorInfo != null                      &&
+               visitorInfo instanceof ShortestUsageMark &&
+               !((ShortestUsageMark)visitorInfo).isCertain();
+    }
+
+
+    protected ShortestUsageMark getShortestUsageMark(VisitorAccepter visitorAccepter)
+    {
+        Object visitorInfo = visitorAccepter.getVisitorInfo();
+
+        return (ShortestUsageMark)visitorInfo;
+    }
+
+
+    // Small utility methods.
+
+    private boolean isCausedBy(ShortestUsageMark shortestUsageMark,
+                               Clazz             clazz)
+    {
+        return recursiveCauseChecker.check(shortestUsageMark, clazz);
+    }
+
+
+    private class MyRecursiveCauseChecker implements ClassVisitor, MemberVisitor
+    {
+        private Clazz   checkClass;
+        private boolean isRecursing;
+
+
+        public boolean check(ShortestUsageMark shortestUsageMark,
+                             Clazz             clazz)
+        {
+            checkClass  = clazz;
+            isRecursing = false;
+
+            shortestUsageMark.acceptClassVisitor(this);
+            shortestUsageMark.acceptMemberVisitor(this);
+
+            return isRecursing;
+        }
+
+        // Implementations for ClassVisitor.
+
+        public void visitProgramClass(ProgramClass programClass)
+        {
+            checkCause(programClass);
+        }
+
+
+        public void visitLibraryClass(LibraryClass libraryClass)
+        {
+            checkCause(libraryClass);
+        }
+
+
+        // Implementations for MemberVisitor.
+
+        public void visitProgramField(ProgramClass programClass, ProgramField programField)
+        {
+            checkCause(programField);
+        }
+
+
+        public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+        {
+            checkCause(programMethod);
+        }
+
+
+        public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
+        {
+             checkCause(libraryField);
+       }
+
+
+        public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+        {
+            checkCause(libraryMethod);
+        }
+
+
+        // Small utility methods.
+
+        private void checkCause(VisitorAccepter visitorAccepter)
+        {
+            if (ShortestUsageMarker.this.isUsed(visitorAccepter))
+            {
+                ShortestUsageMark shortestUsageMark = ShortestUsageMarker.this.getShortestUsageMark(visitorAccepter);
+
+                // Check the class of this mark, if any
+                isRecursing = shortestUsageMark.isCausedBy(checkClass);
+
+                // Check the causing class or method, if still necessary.
+                if (!isRecursing)
+                {
+                    shortestUsageMark.acceptClassVisitor(this);
+                    shortestUsageMark.acceptMemberVisitor(this);
+                }
+            }
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/shrink/ShortestUsagePrinter.java

@@ -0,0 +1,210 @@
+/*
+ * 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.shrink;
+
+import proguard.classfile.*;
+import proguard.classfile.util.ClassUtil;
+import proguard.classfile.visitor.*;
+
+import java.io.PrintStream;
+
+
+/**
+ * This ClassVisitor     and MemberVisitor prints out the reasons why
+ * classes and class members have been marked as being used.
+ *
+ * @see UsageMarker
+ *
+ * @author Eric Lafortune
+ */
+public class ShortestUsagePrinter
+implements   ClassVisitor,
+             MemberVisitor
+{
+    private final ShortestUsageMarker shortestUsageMarker;
+    private final boolean             verbose;
+    private final PrintStream         ps;
+
+
+    /**
+     * Creates a new UsagePrinter that prints verbosely to <code>System.out</code>.
+     * @param shortestUsageMarker the usage marker that was used to mark the
+     *                            classes and class members.
+     */
+    public ShortestUsagePrinter(ShortestUsageMarker shortestUsageMarker)
+    {
+        this(shortestUsageMarker, true);
+    }
+
+
+    /**
+     * Creates a new UsagePrinter that prints to the given stream.
+     * @param shortestUsageMarker the usage marker that was used to mark the
+     *                            classes and class members.
+     * @param verbose             specifies whether the output should be verbose.
+     */
+    public ShortestUsagePrinter(ShortestUsageMarker shortestUsageMarker,
+                                boolean             verbose)
+    {
+        this(shortestUsageMarker, verbose, System.out);
+    }
+
+    /**
+     * Creates a new UsagePrinter that prints to the given stream.
+     * @param shortestUsageMarker the usage marker that was used to mark the
+     *                            classes and class members.
+     * @param verbose             specifies whether the output should be verbose.
+     * @param printStream         the stream to which to print.
+     */
+    public ShortestUsagePrinter(ShortestUsageMarker shortestUsageMarker,
+                                boolean             verbose,
+                                PrintStream         printStream)
+    {
+        this.shortestUsageMarker = shortestUsageMarker;
+        this.verbose             = verbose;
+        this.ps                  = printStream;
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        // Print the name of this class.
+        ps.println(ClassUtil.externalClassName(programClass.getName()));
+
+        // Print the reason for keeping this class.
+        printReason(programClass);
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        // Print the name of this class.
+        ps.println(ClassUtil.externalClassName(libraryClass.getName()));
+
+        // Print the reason for keeping this class.
+        ps.println("  is a library class.\n");
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        // Print the name of this field.
+        String name = programField.getName(programClass);
+        String type = programField.getDescriptor(programClass);
+
+        ps.println(ClassUtil.externalClassName(programClass.getName()) +
+                   (verbose ?
+                        ": " + ClassUtil.externalFullFieldDescription(0, name, type):
+                        "."  + name) +
+                   lineNumberRange(programClass, programField));
+
+        // Print the reason for keeping this method.
+        printReason(programField);
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        // Print the name of this method.
+        String name = programMethod.getName(programClass);
+        String type = programMethod.getDescriptor(programClass);
+
+        ps.println(ClassUtil.externalClassName(programClass.getName()) +
+                   (verbose ?
+                        ": " + ClassUtil.externalFullMethodDescription(programClass.getName(), 0, name, type):
+                        "."  + name) +
+                   lineNumberRange(programClass, programMethod));
+
+        // Print the reason for keeping this method.
+        printReason(programMethod);
+    }
+
+
+    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
+    {
+        // Print the name of this field.
+        String name = libraryField.getName(libraryClass);
+        String type = libraryField.getDescriptor(libraryClass);
+
+        ps.println(ClassUtil.externalClassName(libraryClass.getName()) +
+                   (verbose ?
+                        ": " + ClassUtil.externalFullFieldDescription(0, name, type):
+                        "."  + name));
+
+        // Print the reason for keeping this field.
+        ps.println("  is a library field.\n");
+    }
+
+
+    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+    {
+        // Print the name of this method.
+        String name = libraryMethod.getName(libraryClass);
+        String type = libraryMethod.getDescriptor(libraryClass);
+
+        ps.println(ClassUtil.externalClassName(libraryClass.getName()) +
+                   (verbose ?
+                        ": " + ClassUtil.externalFullMethodDescription(libraryClass.getName(), 0, name, type):
+                        "."  + name));
+
+        // Print the reason for keeping this method.
+        ps.println("  is a library method.\n");
+    }
+
+
+    // Small utility methods.
+
+    private void printReason(VisitorAccepter visitorAccepter)
+    {
+        if (shortestUsageMarker.isUsed(visitorAccepter))
+        {
+            ShortestUsageMark shortestUsageMark = shortestUsageMarker.getShortestUsageMark(visitorAccepter);
+
+            // Print the reason for keeping this class.
+            ps.print("  " + shortestUsageMark.getReason());
+
+            // Print the class or method that is responsible, with its reasons.
+            shortestUsageMark.acceptClassVisitor(this);
+            shortestUsageMark.acceptMemberVisitor(this);
+        }
+        else
+        {
+            ps.println("  is not being kept.\n");
+        }
+    }
+
+
+    /**
+     * Returns the line number range of the given class member, followed by a
+     * colon, or just an empty String if no range is available.
+     */
+    private static String lineNumberRange(ProgramClass programClass, ProgramMember programMember)
+    {
+        String range = programMember.getLineNumberRange(programClass);
+        return range != null ?
+            (" (" + range + ")") :
+            "";
+    }
+}