sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/optimize/info/NoSideEffectMethodMarker.java

@@ -0,0 +1,91 @@
+/*
+ * 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.optimize.info;
+
+import proguard.classfile.*;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.MemberVisitor;
+
+/**
+ * This MemberVisitor marks all methods that it visits as not having any side
+ * effects. It will make the SideEffectMethodMarker consider them as such
+ * without further analysis.
+ *
+ * @see SideEffectMethodMarker
+ * @author Eric Lafortune
+ */
+public class NoSideEffectMethodMarker
+extends      SimplifiedVisitor
+implements   MemberVisitor
+{
+    // A visitor info flag to indicate the visitor accepter is being kept,
+    // but that it doesn't have any side effects.
+    private static final Object KEPT_BUT_NO_SIDE_EFFECTS = new Object();
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitAnyMember(Clazz Clazz, Member member)
+    {
+        // Ignore any attempts to mark fields.
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        markNoSideEffects(programMethod);
+    }
+
+
+    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+    {
+        markNoSideEffects(libraryMethod);
+    }
+
+
+    // Small utility methods.
+
+    private static void markNoSideEffects(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setNoSideEffects();
+        }
+        else
+        {
+            MethodLinker.lastMember(method).setVisitorInfo(KEPT_BUT_NO_SIDE_EFFECTS);
+        }
+    }
+
+
+    public static boolean hasNoSideEffects(Method method)
+    {
+        if (MethodLinker.lastVisitorAccepter(method).getVisitorInfo() == KEPT_BUT_NO_SIDE_EFFECTS)
+        {
+            return true;
+        }
+
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info != null &&
+               info.hasNoSideEffects();
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/NonPrivateMemberMarker.java

@@ -0,0 +1,171 @@
+/*
+ * 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.optimize.info;
+
+import proguard.classfile.*;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.*;
+
+/**
+ * This ClassVisitor marks all class members that can not be made private in the
+ * classes that it visits, and in the classes to which they refer.
+ *
+ * @author Eric Lafortune
+ */
+public class NonPrivateMemberMarker
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             ConstantVisitor,
+             MemberVisitor
+{
+    private final MethodImplementationFilter filteredMethodMarker = new MethodImplementationFilter(this);
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        // Mark all referenced class members in different classes.
+        programClass.constantPoolEntriesAccept(this);
+
+        // Explicitly mark the <clinit> method.
+        programClass.methodAccept(ClassConstants.INTERNAL_METHOD_NAME_CLINIT,
+                                  ClassConstants.INTERNAL_METHOD_TYPE_CLINIT,
+                                  this);
+
+        // Explicitly mark the parameterless <init> method.
+        programClass.methodAccept(ClassConstants.INTERNAL_METHOD_NAME_INIT,
+                                  ClassConstants.INTERNAL_METHOD_TYPE_INIT,
+                                  this);
+
+        // Mark all methods that may have implementations.
+        programClass.methodsAccept(filteredMethodMarker);
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        // Go over all methods.
+        libraryClass.methodsAccept(this);
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        // The referenced class member, if any, can never be made private,
+        // even if it's in the same class.
+        stringConstant.referencedMemberAccept(this);
+    }
+
+
+    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
+    {
+        Clazz referencedClass = refConstant.referencedClass;
+
+        // Is it referring to a class member in another class?
+        // The class member might be in another class, or
+        // it may be referenced through another class.
+        if (referencedClass != null &&
+            !referencedClass.equals(clazz) ||
+            !refConstant.getClassName(clazz).equals(clazz.getName()))
+        {
+            // The referenced class member can never be made private.
+            refConstant.referencedMemberAccept(this);
+        }
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitProgramField(ProgramClass programClass, ProgramField programField)
+    {
+        markCanNotBeMadePrivate(programField);
+    }
+
+
+    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
+    {
+        markCanNotBeMadePrivate(libraryField);
+    }
+
+
+    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+    {
+        markCanNotBeMadePrivate(programMethod);
+    }
+
+
+    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+    {
+        markCanNotBeMadePrivate(libraryMethod);
+    }
+
+
+    // Small utility methods.
+
+    private static void markCanNotBeMadePrivate(Field field)
+    {
+        FieldOptimizationInfo info = FieldOptimizationInfo.getFieldOptimizationInfo(field);
+        if (info != null)
+        {
+            info.setCanNotBeMadePrivate();
+        }
+    }
+
+
+    /**
+     * Returns whether the given field can be made private.
+     */
+    public static boolean canBeMadePrivate(Field field)
+    {
+        FieldOptimizationInfo info = FieldOptimizationInfo.getFieldOptimizationInfo(field);
+        return info != null &&
+               info.canBeMadePrivate();
+    }
+
+
+    private static void markCanNotBeMadePrivate(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setCanNotBeMadePrivate();
+        }
+    }
+
+
+    /**
+     * Returns whether the given method can be made private.
+     */
+    public static boolean canBeMadePrivate(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info != null &&
+               info.canBeMadePrivate();
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/PackageVisibleMemberContainingClassMarker.java

@@ -0,0 +1,85 @@
+/*
+ * 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.optimize.info;
+
+import proguard.classfile.*;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.*;
+
+/**
+ * This ClassVisitor marks all classes that contain package visible members.
+ *
+ * @author Eric Lafortune
+ */
+public class PackageVisibleMemberContainingClassMarker
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             MemberVisitor
+{
+    // Implementations for ClassVisitor.
+
+    public void visitAnyClass(Clazz clazz)
+    {
+        // Check the class itself.
+        if ((clazz.getAccessFlags() & ClassConstants.INTERNAL_ACC_PUBLIC) == 0)
+        {
+            setPackageVisibleMembers(clazz);
+        }
+        else
+        {
+            // Check the members.
+            clazz.fieldsAccept(this);
+            clazz.methodsAccept(this);
+        }
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitAnyMember(Clazz clazz, Member member)
+    {
+        if ((member.getAccessFlags() &
+             (ClassConstants.INTERNAL_ACC_PRIVATE |
+              ClassConstants.INTERNAL_ACC_PUBLIC)) == 0)
+        {
+            setPackageVisibleMembers(clazz);
+        }
+    }
+
+
+    // Small utility methods.
+
+    private static void setPackageVisibleMembers(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        if (info != null)
+        {
+            info.setContainsPackageVisibleMembers();
+        }
+    }
+
+
+    public static boolean containsPackageVisibleMembers(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        return info == null || info.containsPackageVisibleMembers();
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/PackageVisibleMemberInvokingClassMarker.java

@@ -0,0 +1,129 @@
+/*
+ * 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.optimize.info;
+
+import proguard.classfile.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.constant.*;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.*;
+
+/**
+ * This ConstantVisitor marks all classes that refer to package visible classes
+ * or class members.
+ *
+ * @author Eric Lafortune
+ */
+public class PackageVisibleMemberInvokingClassMarker
+extends      SimplifiedVisitor
+implements   ConstantVisitor,
+             ClassVisitor,
+             MemberVisitor
+{
+    private Clazz referencingClass;
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        // Check the referenced class and class member, if any.
+        if (stringConstant.referencedClass != clazz)
+        {
+            referencingClass = clazz;
+
+            stringConstant.referencedClassAccept(this);
+            stringConstant.referencedMemberAccept(this);
+        }
+    }
+
+
+    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
+    {
+        // Check the referenced class and class member.
+        if (refConstant.referencedClass != clazz)
+        {
+            referencingClass = clazz;
+
+            refConstant.referencedClassAccept(this);
+            refConstant.referencedMemberAccept(this);
+        }
+    }
+
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Check the referenced class.
+        if (classConstant.referencedClass != clazz)
+        {
+            referencingClass = clazz;
+
+            classConstant.referencedClassAccept(this);
+        }
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitAnyClass(Clazz clazz)
+    {
+        if ((clazz.getAccessFlags() &
+             ClassConstants.INTERNAL_ACC_PUBLIC) == 0)
+        {
+            setInvokesPackageVisibleMembers(referencingClass);
+        }
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitAnyMember(Clazz clazz, Member member)
+    {
+        if ((member.getAccessFlags() &
+             (ClassConstants.INTERNAL_ACC_PUBLIC |
+              ClassConstants.INTERNAL_ACC_PRIVATE)) == 0)
+        {
+            setInvokesPackageVisibleMembers(referencingClass);
+        }
+    }
+
+
+    // Small utility methods.
+
+    private static void setInvokesPackageVisibleMembers(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        if (info != null)
+        {
+            info.setInvokesPackageVisibleMembers();
+        }
+    }
+
+
+    public static boolean invokesPackageVisibleMembers(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        return info == null || info.invokesPackageVisibleMembers();
+    }
+}