sometsome 1.0.2 → 3.10.42

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

@@ -0,0 +1,174 @@
+/*
+ * 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.attribute.*;
+import proguard.classfile.attribute.visitor.*;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.ClassVisitor;
+
+/**
+ * This AttributeVisitor recursively marks all necessary inner class information
+ * in the attributes that it visits.
+ *
+ * @see UsageMarker
+ *
+ * @author Eric Lafortune
+ */
+public class InnerUsageMarker
+extends      SimplifiedVisitor
+implements   AttributeVisitor,
+             InnerClassesInfoVisitor,
+             ConstantVisitor,
+             ClassVisitor
+{
+    private final UsageMarker usageMarker;
+
+    // Fields acting as a return parameters for several methods.
+    private boolean attributeUsed;
+    private boolean classUsed;
+
+
+    /**
+     * Creates a new InnerUsageMarker.
+     * @param usageMarker the usage marker that is used to mark the classes
+     *                    and class members.
+     */
+    public InnerUsageMarker(UsageMarker usageMarker)
+    {
+        this.usageMarker = usageMarker;
+    }
+
+
+    // Implementations for AttributeVisitor.
+
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+    public void visitInnerClassesAttribute(Clazz clazz, InnerClassesAttribute innerClassesAttribute)
+    {
+        // Mark the necessary inner classes information.
+        attributeUsed = false;
+        innerClassesAttribute.innerClassEntriesAccept(clazz, this);
+
+        if (attributeUsed)
+        {
+            // We got a positive used flag, so some inner class is being used.
+            // Mark this attribute as being used as well.
+            usageMarker.markAsUsed(innerClassesAttribute);
+
+            markConstant(clazz, innerClassesAttribute.u2attributeNameIndex);
+        }
+    }
+
+
+    // Implementations for InnerClassesInfoVisitor.
+
+    public void visitInnerClassesInfo(Clazz clazz, InnerClassesInfo innerClassesInfo)
+    {
+        boolean innerClassesInfoUsed = usageMarker.isUsed(innerClassesInfo);
+
+        if (!innerClassesInfoUsed)
+        {
+            // Check if the inner class (if any) is marked as being used.
+            classUsed = true;
+            innerClassesInfo.innerClassConstantAccept(clazz, this);
+            innerClassesInfoUsed = classUsed;
+
+            // Check if the outer class (if any) is marked as being used.
+            classUsed = true;
+            innerClassesInfo.outerClassConstantAccept(clazz, this);
+            innerClassesInfoUsed &= classUsed;
+
+            // If both the inner class and the outer class are marked as being
+            // used, then mark this InnerClassesInfo as well.
+            if (innerClassesInfoUsed)
+            {
+                usageMarker.markAsUsed(innerClassesInfo);
+
+                innerClassesInfo.innerNameConstantAccept(clazz, this);
+            }
+        }
+
+        // The return value.
+        attributeUsed |= innerClassesInfoUsed;
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        classUsed = usageMarker.isUsed(classConstant);
+
+        // Is the class constant marked as being used?
+        if (!classUsed)
+        {
+            // Check the referenced class.
+            classUsed = true;
+            classConstant.referencedClassAccept(this);
+
+            // Is the referenced class marked as being used?
+            if (classUsed)
+            {
+                // Mark the class constant and its Utf8 constant.
+                usageMarker.markAsUsed(classConstant);
+
+                markConstant(clazz, classConstant.u2nameIndex);
+            }
+        }
+    }
+
+
+    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
+    {
+        usageMarker.markAsUsed(utf8Constant);
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        classUsed = usageMarker.isUsed(programClass);
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        classUsed = true;
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Marks the given constant pool entry of the given class. This includes
+     * visiting any other referenced constant pool entries.
+     */
+    private void markConstant(Clazz clazz, int index)
+    {
+         clazz.constantPoolEntryAccept(index, this);
+    }
+}

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

@@ -0,0 +1,152 @@
+/*
+ * 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.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.ClassVisitor;
+
+
+/**
+ * This ClassVisitor recursively marks all interface
+ * classes that are being used in the visited class.
+ *
+ * @see UsageMarker
+ *
+ * @author Eric Lafortune
+ */
+public class InterfaceUsageMarker
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             ConstantVisitor
+{
+    private final UsageMarker usageMarker;
+
+    // Fields acting as a return parameters for several methods.
+    private boolean used;
+    private boolean anyUsed;
+
+
+    /**
+     * Creates a new InterfaceUsageMarker.
+     * @param usageMarker the usage marker that is used to mark the classes
+     *                    and class members.
+     */
+    public InterfaceUsageMarker(UsageMarker usageMarker)
+    {
+        this.usageMarker = usageMarker;
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        boolean classUsed         = usageMarker.isUsed(programClass);
+        boolean classPossiblyUsed = usageMarker.isPossiblyUsed(programClass);
+
+        if (classUsed || classPossiblyUsed)
+        {
+            // Check if any interfaces are being used.
+            boolean oldAnyUsed = anyUsed;
+            anyUsed = false;
+
+            programClass.interfaceConstantsAccept(this);
+
+            classUsed |= anyUsed;
+            anyUsed = oldAnyUsed;
+
+            // Is this an interface with a preliminary mark?
+            if (classPossiblyUsed)
+            {
+                // Should it be included now?
+                if (classUsed)
+                {
+                    // At least one if this interface's interfaces is being used.
+                    // Mark this interface as well.
+                    usageMarker.markAsUsed(programClass);
+
+                    // Mark this interface's name.
+                    programClass.thisClassConstantAccept(this);
+
+                    // Mark the superclass (java/lang/Object).
+                    programClass.superClassConstantAccept(this);
+                }
+                else
+                {
+                    // Unmark this interface, so we don't bother looking at it again.
+                    usageMarker.markAsUnused(programClass);
+                }
+            }
+        }
+
+        // The return value.
+        used = classUsed;
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        // The return values.
+        used    = true;
+        anyUsed = true;
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        boolean classUsed = usageMarker.isUsed(classConstant);
+
+        if (!classUsed)
+        {
+            // The ClassConstant isn't marked as being used yet. But maybe it
+            // should be included as an interface, so check the actual class.
+            classConstant.referencedClassAccept(this);
+            classUsed = used;
+
+            if (classUsed)
+            {
+                // The class is being used. Mark the ClassConstant as being used
+                // as well.
+                usageMarker.markAsUsed(classConstant);
+
+                clazz.constantPoolEntryAccept(classConstant.u2nameIndex, this);
+            }
+        }
+
+        // The return values.
+        used    =  classUsed;
+        anyUsed |= classUsed;
+    }
+
+
+    public void visitUtf8Constant(Clazz clazz, Utf8Constant utf8Constant)
+    {
+        if (!usageMarker.isUsed(utf8Constant))
+        {
+            usageMarker.markAsUsed(utf8Constant);
+        }
+    }
+}

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

@@ -0,0 +1,183 @@
+/*
+ * 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 class can be used as a mark when keeping classes, class members, and
+ * other elements. It can be certain or preliminary. It also contains additional
+ * information about the reasons why an element is being kept.
+ *
+ * @see ClassShrinker
+ *
+ * @author Eric Lafortune
+ */
+final class ShortestUsageMark
+{
+    private final boolean certain;
+    private final String  reason;
+    private final int     depth;
+    private       Clazz   clazz;
+    private       Member  member;
+
+
+    /**
+     * Creates a new certain ShortestUsageMark.
+     * @param reason the reason for this mark.
+     */
+    public ShortestUsageMark(String reason)
+    {
+        this.certain = true;
+        this.reason  = reason;
+        this.depth   = 0;
+    }
+
+
+    /**
+     * Creates a new certain ShortestUsageMark.
+     * @param previousUsageMark the previous mark to which this one is linked.
+     * @param reason            the reason for this mark.
+     * @param clazz             the class causing this mark.
+     */
+    public ShortestUsageMark(ShortestUsageMark previousUsageMark,
+                             String            reason,
+                             int               cost,
+                             Clazz             clazz)
+    {
+        this(previousUsageMark, reason, cost, clazz, null);
+    }
+
+
+    /**
+     * Creates a new certain ShortestUsageMark.
+     * @param previousUsageMark the previous mark to which this one is linked.
+     * @param reason            the reason for this mark.
+     * @param clazz             the class causing this mark.
+     * @param member            the member in the above class causing this mark.
+     * @param cost              the added cost of following this path.
+     */
+    public ShortestUsageMark(ShortestUsageMark previousUsageMark,
+                             String            reason,
+                             int               cost,
+                             Clazz             clazz,
+                             Member            member)
+    {
+        this.certain = true;
+        this.reason  = reason;
+        this.depth   = previousUsageMark.depth + cost;
+        this.clazz   = clazz;
+        this.member  = member;
+    }
+
+
+    /**
+     * Creates a new ShortestUsageMark, based on another mark.
+     * @param otherUsageMark the other mark, whose properties will be copied.
+     * @param certain        specifies whether this is a certain mark.
+     */
+    public ShortestUsageMark(ShortestUsageMark otherUsageMark,
+                             boolean           certain)
+    {
+        this.certain = certain;
+        this.reason  = otherUsageMark.reason;
+        this.depth   = otherUsageMark.depth;
+        this.clazz   = otherUsageMark.clazz;
+        this.member  = otherUsageMark.member;
+    }
+
+
+    /**
+     * Returns whether this is a certain mark.
+     */
+    public boolean isCertain()
+    {
+        return certain;
+    }
+
+
+    /**
+     * Returns the reason for this mark.
+     */
+    public String getReason()
+    {
+        return reason;
+    }
+
+
+    /**
+     * Returns whether this mark has a shorter chain of reasons than the
+     * given mark.
+     */
+    public boolean isShorter(ShortestUsageMark otherUsageMark)
+    {
+        return this.depth < otherUsageMark.depth;
+    }
+
+
+    /**
+     * Returns whether this is mark is caused by the given class.
+     */
+    public boolean isCausedBy(Clazz clazz)
+    {
+        return clazz.equals(this.clazz);
+    }
+
+
+    /**
+     * Applies the given class visitor to this mark's class, if any,
+     * and if this mark doesn't have a member.
+     */
+    public void acceptClassVisitor(ClassVisitor classVisitor)
+    {
+        if (clazz  != null &&
+            member == null)
+        {
+            clazz.accept(classVisitor);
+        }
+    }
+
+
+    /**
+     * Applies the given class visitor to this mark's member, if any.
+     */
+    public void acceptMemberVisitor(MemberVisitor memberVisitor)
+    {
+        if (clazz  != null &&
+            member != null)
+        {
+            member.accept(clazz, memberVisitor);
+        }
+    }
+
+
+    // Implementations for Object.
+
+    public String toString()
+    {
+        return "certain=" + certain + ", depth="+depth+": " +
+               reason +
+               (clazz      != null ? clazz.getName() : "(none)") + ": " +
+               (member     != null ? member.getName(clazz) : "(none)");
+    }
+}