RubyGems - sometsome - Versions diffs - 1.0.2 → 3.10.42 - Mend

sometsome 1.0.2 → 3.10.42

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (732) hide show

data/lib/proguard4.7/src/proguard/optimize/evaluation/package.html ADDED

@@ -0,0 +1,4 @@
+<body>
+This package contains visitors that perform partial evaluation and subsequent
+optimizations on byte code.
+</body>

data/lib/proguard4.7/src/proguard/optimize/info/AccessMethodMarker.java ADDED

@@ -0,0 +1,202 @@
+/*
+ * 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.*;
+import proguard.classfile.attribute.visitor.*;
+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.*;
+/**
+ * This InstructionVisitor marks the types of class accesses and class member
+ * accesses of the methods whose instructions it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class AccessMethodMarker
+extends      SimplifiedVisitor
+implements   InstructionVisitor,
+             ConstantVisitor,
+             ClassVisitor,
+             MemberVisitor
+{
+    private Method invokingMethod;
+    // 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)
+    {
+        invokingMethod = method;
+        clazz.constantPoolEntryAccept(constantInstruction.constantIndex, this);
+    }
+    // Implementations for ConstantVisitor.
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        // Check the referenced class or class member, if any.
+       stringConstant.referencedClassAccept(this);
+       stringConstant.referencedMemberAccept(this);
+    }
+    public void visitInvokeDynamicConstant(Clazz clazz, InvokeDynamicConstant invokeDynamicConstant)
+    {
+        // Check the bootstrap method.
+        invokeDynamicConstant.bootstrapMethodHandleAccept(clazz, this);
+    }
+    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
+    {
+        // Check the method reference.
+        clazz.constantPoolEntryAccept(methodHandleConstant.u2referenceIndex, this);
+    }
+    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
+    {
+        // Check the referenced class.
+        clazz.constantPoolEntryAccept(refConstant.u2classIndex, this);
+        // Check the referenced class member itself.
+        refConstant.referencedClassAccept(this);
+        refConstant.referencedMemberAccept(this);
+    }
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Check the referenced class.
+       classConstant.referencedClassAccept(this);
+    }
+    // Implementations for ClassVisitor.
+    public void visitAnyClass(Clazz clazz)
+    {
+        int accessFlags = clazz.getAccessFlags();
+        if ((accessFlags & ClassConstants.INTERNAL_ACC_PUBLIC) == 0)
+        {
+            setAccessesPackageCode(invokingMethod);
+        }
+    }
+    // Implementations for MemberVisitor.
+    public void visitAnyMember(Clazz clazz, Member member)
+    {
+        int accessFlags = member.getAccessFlags();
+        if      ((accessFlags & ClassConstants.INTERNAL_ACC_PRIVATE)   != 0)
+        {
+            setAccessesPrivateCode(invokingMethod);
+        }
+        else if ((accessFlags & ClassConstants.INTERNAL_ACC_PROTECTED) != 0)
+        {
+            setAccessesProtectedCode(invokingMethod);
+        }
+        else if ((accessFlags & ClassConstants.INTERNAL_ACC_PUBLIC)    == 0)
+        {
+            setAccessesPackageCode(invokingMethod);
+        }
+    }
+    // Small utility methods.
+    private static void setAccessesPrivateCode(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setAccessesPrivateCode();
+        }
+    }
+    /**
+     * Returns whether the given method accesses private class members.
+     */
+    public static boolean accessesPrivateCode(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info == null || info.accessesPrivateCode();
+    }
+    private static void setAccessesPackageCode(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setAccessesPackageCode();
+        }
+    }
+    /**
+     * Returns whether the given method accesses package visible classes or class
+     * members.
+     */
+    public static boolean accessesPackageCode(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info == null || info.accessesPackageCode();
+    }
+    private static void setAccessesProtectedCode(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setAccessesProtectedCode();
+        }
+    }
+    /**
+     * Returns whether the given method accesses protected class members.
+     */
+    public static boolean accessesProtectedCode(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info == null || info.accessesProtectedCode();
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/BackwardBranchMarker.java ADDED

@@ -0,0 +1,90 @@
+/*
+ * 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.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+/**
+ * This InstructionVisitor marks all methods that branch backward in any of the
+ * instructions that it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class BackwardBranchMarker
+extends      SimplifiedVisitor
+implements   InstructionVisitor
+{
+    // Implementations for InstructionVisitor.
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction) {}
+    public void visitBranchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, BranchInstruction branchInstruction)
+    {
+        markBackwardBranch(method, branchInstruction.branchOffset);
+    }
+    public void visitAnySwitchInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, SwitchInstruction switchInstruction)
+    {
+        markBackwardBranch(method, switchInstruction.defaultOffset);
+        for (int index = 0; index < switchInstruction.jumpOffsets.length; index++)
+        {
+            markBackwardBranch(method, switchInstruction.jumpOffsets[index]);
+        }
+    }
+    // Small utility methods.
+    /**
+     * Marks the given method if the given branch offset is negative.
+     */
+    private void markBackwardBranch(Method method, int branchOffset)
+    {
+        if (branchOffset < 0)
+        {
+            setBranchesBackward(method);
+        }
+    }
+    private static void setBranchesBackward(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setBranchesBackward();
+        }
+    }
+    public static boolean branchesBackward(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info == null || info.branchesBackward();
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/CatchExceptionMarker.java ADDED

@@ -0,0 +1,69 @@
+/*
+ * 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.*;
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+/**
+ * This AttributeVisitor marks all methods that catch exceptions.
+ *
+ * @author Eric Lafortune
+ */
+public class CatchExceptionMarker
+extends      SimplifiedVisitor
+implements   AttributeVisitor
+{
+    // Implementations for AttributeVisitor.
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        if (codeAttribute.u2exceptionTableLength > 0)
+        {
+            markCatchException(method);
+        }
+    }
+    // Small utility methods.
+    private static void markCatchException(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        if (info != null)
+        {
+            info.setCatchesExceptions();
+        }
+    }
+    public static boolean catchesExceptions(Method method)
+    {
+        MethodOptimizationInfo info = MethodOptimizationInfo.getMethodOptimizationInfo(method);
+        return info == null ||
+               info.catchesExceptions();
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/CaughtClassFilter.java ADDED

@@ -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 caught as exceptions.
+ *
+ * @see CaughtClassMarker
+ * @author Eric Lafortune
+ */
+public class CaughtClassFilter
+implements   ClassVisitor
+{
+    private final ClassVisitor classVisitor;
+    public CaughtClassFilter(ClassVisitor classVisitor)
+    {
+        this.classVisitor = classVisitor;
+    }
+    // Implementations for ClassVisitor.
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        if (CaughtClassMarker.isCaught(programClass))
+        {
+            classVisitor.visitProgramClass(programClass);
+        }
+    }
+    public void visitLibraryClass(LibraryClass libraryClass)
+    {
+        if (CaughtClassMarker.isCaught(libraryClass))
+        {
+            classVisitor.visitLibraryClass(libraryClass);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/optimize/info/CaughtClassMarker.java ADDED

@@ -0,0 +1,64 @@
+/*
+ * 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;
+/**
+ * This ClassVisitor marks all program classes that it visits as caught.
+ * This means that these classes are exception classes that occur in exception
+ * handlers.
+ *
+ * @author Eric Lafortune
+ */
+public class CaughtClassMarker
+implements   ClassVisitor
+{
+    // Implementations for ClassVisitor.
+    public void visitLibraryClass(LibraryClass libraryClass) {}
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        setCaught(programClass);
+    }
+    // Small utility methods.
+    private static void setCaught(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        if (info != null)
+        {
+            info.setCaught();
+        }
+    }
+    public static boolean isCaught(Clazz clazz)
+    {
+        ClassOptimizationInfo info = ClassOptimizationInfo.getClassOptimizationInfo(clazz);
+        return info == null || info.isCaught();
+    }
+}