sometsome 1.0.2 → 3.10.42

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

@@ -0,0 +1,165 @@
+/*
+ * 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.Clazz;
+
+/**
+ * This class stores some optimization information that can be attached to
+ * a class.
+ *
+ * @author Eric Lafortune
+ */
+public class ClassOptimizationInfo
+{
+    private boolean isInstantiated                = false;
+    private boolean isInstanceofed                = false;
+    private boolean isDotClassed                  = false;
+    private boolean isCaught                      = false;
+    private boolean containsStaticInitializer     = false;
+    private boolean containsPackageVisibleMembers = false;
+    private boolean invokesPackageVisibleMembers  = false;
+    private Clazz   targetClass;
+
+
+    public void setInstantiated()
+    {
+        isInstantiated = true;
+    }
+
+
+    public boolean isInstantiated()
+    {
+        return isInstantiated;
+    }
+
+
+    public void setInstanceofed()
+    {
+        isInstanceofed = true;
+    }
+
+
+    public boolean isInstanceofed()
+    {
+        return isInstanceofed;
+    }
+
+
+    public void setDotClassed()
+    {
+        isDotClassed = true;
+    }
+
+
+    public boolean isDotClassed()
+    {
+        return isDotClassed;
+    }
+
+
+    public void setCaught()
+    {
+        isCaught = true;
+    }
+
+
+    public boolean isCaught()
+    {
+        return isCaught;
+    }
+
+
+    public void setContainsStaticInitializer()
+    {
+        containsStaticInitializer = true;
+    }
+
+
+    public boolean containsStaticInitializer()
+    {
+        return containsStaticInitializer;
+    }
+
+
+    public void setContainsPackageVisibleMembers()
+    {
+        containsPackageVisibleMembers = true;
+    }
+
+
+    public boolean containsPackageVisibleMembers()
+    {
+        return containsPackageVisibleMembers;
+    }
+
+
+    public void setInvokesPackageVisibleMembers()
+    {
+        invokesPackageVisibleMembers = true;
+    }
+
+
+    public boolean invokesPackageVisibleMembers()
+    {
+        return invokesPackageVisibleMembers;
+    }
+
+
+    public void setTargetClass(Clazz targetClass)
+    {
+        this.targetClass = targetClass;
+    }
+
+
+    public Clazz getTargetClass()
+    {
+        return targetClass;
+    }
+
+
+    public void merge(ClassOptimizationInfo other)
+    {
+        this.isInstantiated                |= other.isInstantiated;
+        this.isInstanceofed                |= other.isInstanceofed;
+        this.isDotClassed                  |= other.isDotClassed;
+        this.isCaught                      |= other.isCaught;
+        this.containsStaticInitializer     |= other.containsStaticInitializer;
+        this.containsPackageVisibleMembers |= other.containsPackageVisibleMembers;
+        this.invokesPackageVisibleMembers  |= other.invokesPackageVisibleMembers;
+    }
+
+
+    public static void setClassOptimizationInfo(Clazz clazz)
+    {
+        clazz.setVisitorInfo(new ClassOptimizationInfo());
+    }
+
+
+    public static ClassOptimizationInfo getClassOptimizationInfo(Clazz clazz)
+    {
+        Object visitorInfo = clazz.getVisitorInfo();
+
+        return visitorInfo instanceof ClassOptimizationInfo ?
+            (ClassOptimizationInfo)visitorInfo :
+            null;
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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.ClassVisitor;
+import proguard.optimize.KeepMarker;
+
+/**
+ * This ClassVisitor attaches a ClassOptimizationInfo instance to every class
+ * that is not being kept that it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class ClassOptimizationInfoSetter
+extends      SimplifiedVisitor
+implements   ClassVisitor
+{
+    // Implementations for MemberVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        if (!KeepMarker.isKept(programClass))
+        {
+            ClassOptimizationInfo.setClassOptimizationInfo(programClass);
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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.visitor.ClassVisitor;
+
+/**
+ * This ClassVisitor delegates all its method calls to another ClassVisitor,
+ * but only for Clazz objects that are used in a .class construct.
+ *
+ * @see DotClassMarker
+ * @author Eric Lafortune
+ */
+public class DotClassFilter
+implements   ClassVisitor
+{
+    private final ClassVisitor classVisitor;
+
+
+    public DotClassFilter(ClassVisitor classVisitor)
+    {
+        this.classVisitor = classVisitor;
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        if (DotClassMarker.isDotClassed(programClass))
+        {
+            classVisitor.visitProgramClass(programClass);
+        }
+    }
+
+
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        if (DotClassMarker.isDotClassed(libraryClass))
+        {
+            classVisitor.visitLibraryClass(libraryClass);
+        }
+    }
+}

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

@@ -0,0 +1,96 @@
+/*
+ * 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.attribute.CodeAttribute;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.ClassVisitor;
+
+/**
+ * This InstructionVisitor marks all classes that are used in a .class
+ * construct by any of the instructions that it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class DotClassMarker
+extends      SimplifiedVisitor
+implements   InstructionVisitor,
+             ConstantVisitor,
+             ClassVisitor
+{
+    // Implementations for InstructionVisitor.
+
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
+
+
+    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
+    {
+        if (constantInstruction.opcode == InstructionConstants.OP_LDC ||
+            constantInstruction.opcode == InstructionConstants.OP_LDC_W)
+        {
+            clazz.constantPoolEntryAccept(constantInstruction.constantIndex, this);
+        }
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        classConstant.referencedClassAccept(this);
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitLibraryClass(LibraryClass libraryClass) {}
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        setDotClassed(programClass);
+    }
+
+
+    // Small utility methods.
+
+    private static void setDotClassed(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        if (info != null)
+        {
+            info.setDotClassed();
+        }
+    }
+
+
+    public static boolean isDotClassed(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        return info == null || info.isDotClassed();
+    }
+}

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

@@ -0,0 +1,193 @@
+/*
+ * 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.attribute.CodeAttribute;
+import proguard.classfile.constant.RefConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+import proguard.classfile.visitor.MemberVisitor;
+
+/**
+ * This class can tell whether an instruction might throw exceptions.
+ *
+ * @author Eric Lafortune
+ */
+public class ExceptionInstructionChecker
+extends      SimplifiedVisitor
+implements   InstructionVisitor
+//             ConstantVisitor,
+//             MemberVisitor
+{
+    // A return value for the visitor methods.
+    private boolean mayThrowExceptions;
+
+
+    /**
+     * Returns whether the given instruction may throw exceptions.
+     */
+    public boolean mayThrowExceptions(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
+    {
+        mayThrowExceptions = false;
+
+        instruction.accept(clazz, method,  codeAttribute, offset, this);
+
+        return mayThrowExceptions;
+    }
+
+
+    // Implementations for InstructionVisitor.
+
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
+
+
+    public void visitSimpleInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SimpleInstruction simpleInstruction)
+    {
+        byte opcode = simpleInstruction.opcode;
+
+        // Check for instructions that may throw exceptions.
+        // Note that monitorexit can not sensibly throw exceptions, except the
+        // broken and deprecated asynchronous ThreadDeath. Removing the
+        // artificial infinite looping exception blocks that recent compilers
+        // add does not strictly follow the JVM specs, but it does have the
+        // additional benefit of avoiding a bug in the JVM in JDK 1.1.
+        switch (opcode)
+        {
+            case InstructionConstants.OP_IDIV:
+            case InstructionConstants.OP_LDIV:
+            case InstructionConstants.OP_IREM:
+            case InstructionConstants.OP_LREM:
+            case InstructionConstants.OP_IALOAD:
+            case InstructionConstants.OP_LALOAD:
+            case InstructionConstants.OP_FALOAD:
+            case InstructionConstants.OP_DALOAD:
+            case InstructionConstants.OP_AALOAD:
+            case InstructionConstants.OP_BALOAD:
+            case InstructionConstants.OP_CALOAD:
+            case InstructionConstants.OP_SALOAD:
+            case InstructionConstants.OP_IASTORE:
+            case InstructionConstants.OP_LASTORE:
+            case InstructionConstants.OP_FASTORE:
+            case InstructionConstants.OP_DASTORE:
+            case InstructionConstants.OP_AASTORE:
+            case InstructionConstants.OP_BASTORE:
+            case InstructionConstants.OP_CASTORE:
+            case InstructionConstants.OP_SASTORE:
+            case InstructionConstants.OP_NEWARRAY:
+            case InstructionConstants.OP_ARRAYLENGTH:
+            case InstructionConstants.OP_ATHROW:
+            case InstructionConstants.OP_MONITORENTER:
+                // These instructions may throw exceptions.
+                mayThrowExceptions = true;
+        }
+
+    }
+
+
+    public void visitConstantInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, ConstantInstruction constantInstruction)
+    {
+        byte opcode = constantInstruction.opcode;
+
+        // Check for instructions that may throw exceptions.
+        switch (opcode)
+        {
+            case InstructionConstants.OP_GETSTATIC:
+            case InstructionConstants.OP_PUTSTATIC:
+            case InstructionConstants.OP_GETFIELD:
+            case InstructionConstants.OP_PUTFIELD:
+            case InstructionConstants.OP_INVOKEVIRTUAL:
+            case InstructionConstants.OP_INVOKESPECIAL:
+            case InstructionConstants.OP_INVOKESTATIC:
+            case InstructionConstants.OP_INVOKEINTERFACE:
+            case InstructionConstants.OP_INVOKEDYNAMIC:
+            case InstructionConstants.OP_NEW:
+            case InstructionConstants.OP_ANEWARRAY:
+            case InstructionConstants.OP_CHECKCAST:
+            case InstructionConstants.OP_INSTANCEOF:
+            case InstructionConstants.OP_MULTIANEWARRAY:
+                // These instructions may throw exceptions.
+                mayThrowExceptions = true;
+        }
+
+//          case InstructionConstants.OP_INVOKEVIRTUAL:
+//          case InstructionConstants.OP_INVOKESPECIAL:
+//          case InstructionConstants.OP_INVOKESTATIC:
+//          case InstructionConstants.OP_INVOKEINTERFACE:
+//            // Check if the invoking the method may throw an exception.
+//            clazz.constantPoolEntryAccept(constantInstruction.constantIndex, this);
+    }
+
+
+//    // Implementations for ConstantVisitor.
+//
+//    public void visitAnyMethodrefConstant(Clazz clazz, RefConstant refConstant)
+//    {
+//        Member referencedMember = refConstant.referencedMember;
+//
+//        // Do we have a reference to the method?
+//        if (referencedMember == null)
+//        {
+//            // We'll have to assume invoking the unknown method may throw an
+//            // an exception.
+//            mayThrowExceptions = true;
+//        }
+//        else
+//        {
+//            // First check the referenced method itself.
+//            refConstant.referencedMemberAccept(this);
+//
+//            // If the result isn't conclusive, check down the hierarchy.
+//            if (!mayThrowExceptions)
+//            {
+//                Clazz  referencedClass  = refConstant.referencedClass;
+//                Method referencedMethod = (Method)referencedMember;
+//
+//                // Check all other implementations of the method in the class
+//                // hierarchy.
+//                referencedClass.methodImplementationsAccept(referencedMethod,
+//                                                            false,
+//                                                            false,
+//                                                            true,
+//                                                            true,
+//                                                            this);
+//            }
+//        }
+//    }
+//
+//
+//    // Implementations for MemberVisitor.
+//
+//    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
+//    {
+//        mayThrowExceptions = mayThrowExceptions ||
+//                             ExceptionMethodMarker.mayThrowExceptions(programMethod);
+//    }
+//
+//
+//    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
+//    {
+//        mayThrowExceptions = mayThrowExceptions ||
+//                             !NoExceptionMethodMarker.doesntThrowExceptions(libraryMethod);
+//    }
+}