sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/classfile/constant/visitor/ConstantVisitor.java

@@ -0,0 +1,49 @@
+/*
+ * 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.classfile.constant.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.constant.*;
+
+
+/**
+ * This interface specifies the methods for a visitor of <code>Constant</code>
+ * objects.
+ *
+ * @author Eric Lafortune
+ */
+public interface ConstantVisitor
+{
+    public void visitIntegerConstant(           Clazz clazz, IntegerConstant            integerConstant);
+    public void visitLongConstant(              Clazz clazz, LongConstant               longConstant);
+    public void visitFloatConstant(             Clazz clazz, FloatConstant              floatConstant);
+    public void visitDoubleConstant(            Clazz clazz, DoubleConstant             doubleConstant);
+    public void visitStringConstant(            Clazz clazz, StringConstant             stringConstant);
+    public void visitUtf8Constant(              Clazz clazz, Utf8Constant               utf8Constant);
+    public void visitInvokeDynamicConstant(     Clazz clazz, InvokeDynamicConstant      invokeDynamicConstant);
+    public void visitMethodHandleConstant(      Clazz clazz, MethodHandleConstant       methodHandleConstant);
+    public void visitFieldrefConstant(          Clazz clazz, FieldrefConstant           fieldrefConstant);
+    public void visitInterfaceMethodrefConstant(Clazz clazz, InterfaceMethodrefConstant interfaceMethodrefConstant);
+    public void visitMethodrefConstant(         Clazz clazz, MethodrefConstant          methodrefConstant);
+    public void visitClassConstant(             Clazz clazz, ClassConstant              classConstant);
+    public void visitMethodTypeConstant(        Clazz clazz, MethodTypeConstant         methodTypeConstant);
+    public void visitNameAndTypeConstant(       Clazz clazz, NameAndTypeConstant        nameAndTypeConstant);
+}

data/lib/proguard4.7/src/proguard/classfile/constant/visitor/ExceptClassConstantFilter.java

@@ -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.classfile.constant.visitor;
+
+import proguard.classfile.*;
+import proguard.classfile.editor.*;
+import proguard.classfile.attribute.*;
+import proguard.classfile.attribute.annotation.*;
+import proguard.classfile.attribute.preverification.*;
+import proguard.classfile.constant.ClassConstant;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+
+/**
+ * This <code>ConstantVisitor</code> delegates its visits to class constants
+ * to another given <code>ConstantVisitor</code>, except for one given class.
+ *
+ * @author Eric Lafortune
+ */
+public class ExceptClassConstantFilter
+extends      SimplifiedVisitor
+implements   ConstantVisitor
+{
+    private final String           exceptClassName;
+    private final ConstantVisitor constantVisitor;
+
+
+    /**
+     * Creates a new ExceptClassConstantFilter.
+     * @param exceptClassName the name of the class that will not be visited.
+     * @param constantVisitor the <code>ConstantVisitor</code> to which visits
+     *                        will be delegated.
+     */
+    public ExceptClassConstantFilter(String          exceptClassName,
+                                     ConstantVisitor constantVisitor)
+    {
+        this.exceptClassName = exceptClassName;
+        this.constantVisitor = constantVisitor;
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        if (!classConstant.getName(clazz).equals(exceptClassName))
+        {
+            constantVisitor.visitClassConstant(clazz, classConstant);
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/constant/visitor/MethodrefTraveler.java

@@ -0,0 +1,60 @@
+/*
+ * 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.classfile.constant.visitor;
+
+import proguard.classfile.Clazz;
+import proguard.classfile.attribute.*;
+import proguard.classfile.constant.*;
+import proguard.classfile.util.SimplifiedVisitor;
+
+/**
+ * This ConstantVisitor travels from any method handle constants that it visits
+ * to their methodref constants, and applies a given constant visitor.
+ *
+ * @author Eric Lafortune
+ */
+public class MethodrefTraveler
+extends      SimplifiedVisitor
+implements   ConstantVisitor
+{
+    private ConstantVisitor methodrefConstantVisitor;
+
+
+    /**
+     * Creates a new v that will delegate to the given constant visitor.
+     */
+    public MethodrefTraveler(ConstantVisitor methodrefConstantVisitor)
+    {
+        this.methodrefConstantVisitor = methodrefConstantVisitor;
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+
+    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
+    {
+        clazz.constantPoolEntryAccept(methodHandleConstant.u2referenceIndex,
+                                      methodrefConstantVisitor);
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/constant/visitor/package.html

@@ -0,0 +1,3 @@
+<body>
+This package contains visitors for class constants.
+</body>

data/lib/proguard4.7/src/proguard/classfile/editor/AccessFixer.java

@@ -0,0 +1,180 @@
+/*
+ * 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.classfile.editor;
+
+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.*;
+import proguard.classfile.visitor.*;
+
+/**
+ * This ConstantVisitor fixes the access modifiers of all classes and class
+ * members that are referenced by the constants that it visits.
+ *
+ * @author Eric Lafortune
+ */
+public class AccessFixer
+extends      SimplifiedVisitor
+implements   ConstantVisitor,
+             ClassVisitor,
+             MemberVisitor
+{
+    private MyReferencedClassFinder referencedClassFinder = new MyReferencedClassFinder();
+
+    private Clazz referencingClass;
+    private Clazz referencedClass;
+
+
+    // Implementations for ConstantVisitor.
+
+    public void visitAnyConstant(Clazz clazz, Constant constant) {}
+
+
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        referencingClass = clazz;
+        referencedClass  = stringConstant.referencedClass;
+
+        // Make sure the access flags of the referenced class or class member,
+        // if any, are acceptable.
+        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)
+    {
+        referencingClass = clazz;
+
+        // Remember the specified class, since it might be different from
+        // the referenced class that actually contains the class member.
+        clazz.constantPoolEntryAccept(refConstant.u2classIndex, referencedClassFinder);
+
+        // Make sure the access flags of the referenced class member are
+        // acceptable.
+        refConstant.referencedMemberAccept(this);
+    }
+
+
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        referencingClass = clazz;
+
+        // Make sure the access flags of the referenced class are acceptable.
+        classConstant.referencedClassAccept(this);
+    }
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitLibraryClass(LibraryClass libraryClass) {}
+
+
+    public void visitProgramClass(ProgramClass programClass)
+    {
+        int currentAccessFlags = programClass.getAccessFlags();
+        int currentAccessLevel = AccessUtil.accessLevel(currentAccessFlags);
+
+        // Compute the required access level.
+        Clazz referencingClass = this.referencingClass;
+        int requiredAccessLevel =
+            inSamePackage(programClass, referencingClass) ? AccessUtil.PACKAGE_VISIBLE :
+                                                            AccessUtil.PUBLIC;
+
+        // Fix the class access flags if necessary.
+        if (currentAccessLevel < requiredAccessLevel)
+        {
+            programClass.u2accessFlags =
+                AccessUtil.replaceAccessFlags(currentAccessFlags,
+                                              AccessUtil.accessFlags(requiredAccessLevel));
+        }
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitLibraryMember(LibraryClass libraryClass, LibraryMember libraryMember) {}
+
+
+    public void visitProgramMember(ProgramClass programClass, ProgramMember programMember)
+    {
+        int currentAccessFlags = programMember.getAccessFlags();
+        int currentAccessLevel = AccessUtil.accessLevel(currentAccessFlags);
+
+        // Compute the required access level.
+        int requiredAccessLevel =
+            programClass.equals(referencingClass)         ? AccessUtil.PRIVATE         :
+            inSamePackage(programClass, referencingClass) ? AccessUtil.PACKAGE_VISIBLE :
+            referencedClass.extends_(referencingClass) &&
+            referencingClass.extends_(programClass)       ? AccessUtil.PROTECTED       :
+                                                            AccessUtil.PUBLIC;
+
+        // Fix the class member access flags if necessary.
+        if (currentAccessLevel < requiredAccessLevel)
+        {
+            programMember.u2accessFlags =
+                AccessUtil.replaceAccessFlags(currentAccessFlags,
+                                              AccessUtil.accessFlags(requiredAccessLevel));
+        }
+    }
+
+
+    /**
+     * This ConstantVisitor returns the referenced class of the class constant
+     * that it visits.
+     */
+    private class MyReferencedClassFinder
+    extends       SimplifiedVisitor
+    implements    ConstantVisitor
+    {
+        // Implementations for ConstantVisitor.
+        public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+        {
+            referencedClass = classConstant.referencedClass;
+        }
+    }
+
+
+    // Small utility methods.
+
+    private boolean inSamePackage(ProgramClass class1, Clazz class2)
+    {
+        return ClassUtil.internalPackageName(class1.getName()).equals(
+               ClassUtil.internalPackageName(class2.getName()));
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/editor/AnnotationAdder.java

@@ -0,0 +1,153 @@
+/*
+ * 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.classfile.editor;
+
+import proguard.classfile.*;
+import proguard.classfile.attribute.annotation.*;
+import proguard.classfile.attribute.annotation.visitor.AnnotationVisitor;
+import proguard.classfile.util.SimplifiedVisitor;
+
+/**
+ * This AnnotationVisitor adds all annotations that it visits to the given
+ * target annotation element value, target annotation attribute, or target
+ * parameter annotation attribute.
+ *
+ * @author Eric Lafortune
+ */
+public class AnnotationAdder
+extends      SimplifiedVisitor
+implements   AnnotationVisitor
+{
+    private static final ElementValue[] EMPTY_ELEMENT_VALUES = new ElementValue[0];
+
+
+    private final ProgramClass                        targetClass;
+    private final AnnotationElementValue              targetAnnotationElementValue;
+    private final AnnotationsAttributeEditor          annotationsAttributeEditor;
+    private final ParameterAnnotationsAttributeEditor parameterAnnotationsAttributeEditor;
+
+    private final ConstantAdder constantAdder;
+
+
+    /**
+     * Creates a new AnnotationAdder that will copy annotations into the given
+     * target annotation element value.
+     */
+    public AnnotationAdder(ProgramClass           targetClass,
+                           AnnotationElementValue targetAnnotationElementValue)
+    {
+        this.targetClass                         = targetClass;
+        this.targetAnnotationElementValue        = targetAnnotationElementValue;
+        this.annotationsAttributeEditor          = null;
+        this.parameterAnnotationsAttributeEditor = null;
+
+        constantAdder = new ConstantAdder(targetClass);
+    }
+
+
+    /**
+     * Creates a new AnnotationAdder that will copy annotations into the given
+     * target annotations attribute.
+     */
+    public AnnotationAdder(ProgramClass         targetClass,
+                           AnnotationsAttribute targetAnnotationsAttribute)
+    {
+        this.targetClass                         = targetClass;
+        this.targetAnnotationElementValue        = null;
+        this.annotationsAttributeEditor          = new AnnotationsAttributeEditor(targetAnnotationsAttribute);
+        this.parameterAnnotationsAttributeEditor = null;
+
+        constantAdder = new ConstantAdder(targetClass);
+    }
+
+
+    /**
+     * Creates a new AnnotationAdder that will copy annotations into the given
+     * target parameter annotations attribute.
+     */
+    public AnnotationAdder(ProgramClass                  targetClass,
+                           ParameterAnnotationsAttribute targetParameterAnnotationsAttribute)
+    {
+        this.targetClass                         = targetClass;
+        this.targetAnnotationElementValue        = null;
+        this.annotationsAttributeEditor          = null;
+        this.parameterAnnotationsAttributeEditor = new ParameterAnnotationsAttributeEditor(targetParameterAnnotationsAttribute);
+
+        constantAdder = new ConstantAdder(targetClass);
+    }
+
+
+    // Implementations for AnnotationVisitor.
+
+    public void visitAnnotation(Clazz clazz, Annotation annotation)
+    {
+        Annotation newAnnotation =
+            new Annotation(constantAdder.addConstant(clazz, annotation.u2typeIndex),
+                           0,
+                           annotation.u2elementValuesCount > 0 ?
+                               new ElementValue[annotation.u2elementValuesCount] :
+                               EMPTY_ELEMENT_VALUES);
+
+        // TODO: Clone array.
+        newAnnotation.referencedClasses = annotation.referencedClasses;
+
+        // Add the element values.
+        annotation.elementValuesAccept(clazz,
+                                       new ElementValueAdder(targetClass,
+                                                             newAnnotation,
+                                                             false));
+
+        // What's the target?
+        if (targetAnnotationElementValue != null)
+        {
+            // Simply set the completed annotation.
+            targetAnnotationElementValue.annotationValue = newAnnotation;
+        }
+        else
+        {
+            // Add the completed annotation.
+            annotationsAttributeEditor.addAnnotation(newAnnotation);
+        }
+    }
+
+
+    public void visitAnnotation(Clazz clazz, Method method, int parameterIndex, Annotation annotation)
+    {
+        Annotation newAnnotation =
+            new Annotation(constantAdder.addConstant(clazz, annotation.u2typeIndex),
+                           0,
+                           annotation.u2elementValuesCount > 0 ?
+                               new ElementValue[annotation.u2elementValuesCount] :
+                               EMPTY_ELEMENT_VALUES);
+
+        // TODO: Clone array.
+        newAnnotation.referencedClasses = annotation.referencedClasses;
+
+        // Add the element values.
+        annotation.elementValuesAccept(clazz,
+                                       new ElementValueAdder(targetClass,
+                                                             newAnnotation,
+                                                             false));
+
+        // Add the completed annotation.
+        parameterAnnotationsAttributeEditor.addAnnotation(parameterIndex, newAnnotation);
+    }
+}