RubyGems - sometsome - Versions diffs - 3.10.50 → 3.10.50.33 - Mend

sometsome 3.10.50 → 3.10.50.33

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 (733) hide show

data/lib/proguard4.7/src/proguard/classfile/package.html DELETED

@@ -1,15 +0,0 @@
-<body>
-This package contains classes to represent the various elements of class files.
-<p>
-A class file is represented by the <code>{@link proguard.classfile.ClassFile
-ClassFile}</code> interface. This interface currently has two alternative
-representations:
-<ul>
-<li><code>{@link ProgramClassFile ProgramClassFile}</code>:
-    a complete representation that can be read, modified, and written back.
-<li><code>{@link LibraryClassFile LibraryClassFile}</code>:
-    an incomplete representation that can be only be read. It is however
-    more compact than <code>ProgramClassFile</code>, and sufficient for
-    analyzing class files from library jars.
-</ul>
-</body>

data/lib/proguard4.7/src/proguard/classfile/util/AccessUtil.java DELETED

@@ -1,105 +0,0 @@
-/*
- * 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.util;
-import proguard.classfile.ClassConstants;
-/**
- * Utility methods for working with access flags. For convenience, this class
- * defines access levels, in ascending order: <code>PRIVATE</code>,
- * <code>PACKAGE_VISIBLE</code>, <code>PROTECTED</code>, and <code>PUBLIC</code>.
- *
- * @author Eric Lafortune
- */
-public class AccessUtil
-{
-    public static final int PRIVATE         = 0;
-    public static final int PACKAGE_VISIBLE = 1;
-    public static final int PROTECTED       = 2;
-    public static final int PUBLIC          = 3;
-    // The mask of access flags.
-    private static final int ACCESS_MASK =
-        ClassConstants.INTERNAL_ACC_PUBLIC  |
-        ClassConstants.INTERNAL_ACC_PRIVATE |
-        ClassConstants.INTERNAL_ACC_PROTECTED;
-    /**
-     * Returns the corresponding access level of the given access flags.
-     * @param accessFlags the internal access flags.
-     * @return the corresponding access level: <code>PRIVATE</code>,
-     *         <code>PACKAGE_VISIBLE</code>, <code>PROTECTED</code>, or
-     *         <code>PUBLIC</code>.
-     */
-    public static int accessLevel(int accessFlags)
-    {
-        switch (accessFlags & ACCESS_MASK)
-        {
-            case ClassConstants.INTERNAL_ACC_PRIVATE:   return PRIVATE;
-            default:                                    return PACKAGE_VISIBLE;
-            case ClassConstants.INTERNAL_ACC_PROTECTED: return PROTECTED;
-            case ClassConstants.INTERNAL_ACC_PUBLIC:    return PUBLIC;
-        }
-    }
-    /**
-     * Returns the corresponding access flags of the given access level.
-     * @param accessLevel the access level: <code>PRIVATE</code>,
-     *                    <code>PACKAGE_VISIBLE</code>, <code>PROTECTED</code>,
-     *                    or <code>PUBLIC</code>.
-     * @return the corresponding internal access flags,  the internal access
-     *         flags as a logical bit mask of <code>INTERNAL_ACC_PRIVATE</code>,
-     *         <code>INTERNAL_ACC_PROTECTED</code>, and
-     *         <code>INTERNAL_ACC_PUBLIC</code>.
-     */
-    public static int accessFlags(int accessLevel)
-    {
-        switch (accessLevel)
-        {
-            case PRIVATE:   return ClassConstants.INTERNAL_ACC_PRIVATE;
-            default:        return 0;
-            case PROTECTED: return ClassConstants.INTERNAL_ACC_PROTECTED;
-            case PUBLIC:    return ClassConstants.INTERNAL_ACC_PUBLIC;
-        }
-    }
-    /**
-     * Replaces the access part of the given access flags.
-     * @param accessFlags the internal access flags.
-     * @param accessFlags the new internal access flags.
-     */
-    public static int replaceAccessFlags(int accessFlags, int newAccessFlags)
-    {
-        // A private class member should not be explicitly final.
-        if (newAccessFlags == ClassConstants.INTERNAL_ACC_PRIVATE)
-        {
-            accessFlags &= ~ClassConstants.INTERNAL_ACC_FINAL;
-        }
-        return (accessFlags    & ~ACCESS_MASK) |
-               (newAccessFlags &  ACCESS_MASK);
-    }
-}

data/lib/proguard4.7/src/proguard/classfile/util/ClassReferenceInitializer.java DELETED

@@ -1,559 +0,0 @@
-/*
- * 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.util;
-import proguard.classfile.*;
-import proguard.classfile.attribute.*;
-import proguard.classfile.attribute.annotation.*;
-import proguard.classfile.attribute.annotation.visitor.*;
-import proguard.classfile.attribute.visitor.*;
-import proguard.classfile.constant.*;
-import proguard.classfile.constant.visitor.ConstantVisitor;
-import proguard.classfile.visitor.*;
-/**
- * This ClassVisitor initializes the references of all classes that
- * it visits.
- * <p>
- * All class constant pool entries get direct references to the corresponding
- * classes. These references make it more convenient to travel up and across
- * the class hierarchy.
- * <p>
- * All field and method reference constant pool entries get direct references
- * to the corresponding classes, fields, and methods.
- * <p>
- * All name and type constant pool entries get a list of direct references to
- * the classes listed in the type.
- * <p>
- * This visitor optionally prints warnings if some items can't be found.
- * <p>
- * The class hierarchy must be initialized before using this visitor.
- *
- * @author Eric Lafortune
- */
-public class ClassReferenceInitializer
-extends      SimplifiedVisitor
-implements   ClassVisitor,
-             MemberVisitor,
-             ConstantVisitor,
-             AttributeVisitor,
-             LocalVariableInfoVisitor,
-             LocalVariableTypeInfoVisitor,
-             AnnotationVisitor,
-             ElementValueVisitor
-{
-    private final ClassPool      programClassPool;
-    private final ClassPool      libraryClassPool;
-    private final WarningPrinter missingClassWarningPrinter;
-    private final WarningPrinter missingMemberWarningPrinter;
-    private final WarningPrinter dependencyWarningPrinter;
-    private final MemberFinder memberFinder = new MemberFinder();
-    /**
-     * Creates a new ClassReferenceInitializer that initializes the references
-     * of all visited class files, optionally printing warnings if some classes
-     * or class members can't be found or if they are in the program class pool.
-     */
-    public ClassReferenceInitializer(ClassPool      programClassPool,
-                                     ClassPool      libraryClassPool,
-                                     WarningPrinter missingClassWarningPrinter,
-                                     WarningPrinter missingMemberWarningPrinter,
-                                     WarningPrinter dependencyWarningPrinter)
-    {
-        this.programClassPool            = programClassPool;
-        this.libraryClassPool            = libraryClassPool;
-        this.missingClassWarningPrinter  = missingClassWarningPrinter;
-        this.missingMemberWarningPrinter = missingMemberWarningPrinter;
-        this.dependencyWarningPrinter    = dependencyWarningPrinter;
-    }
-    // Implementations for ClassVisitor.
-    public void visitProgramClass(ProgramClass programClass)
-    {
-        // Initialize the constant pool entries.
-        programClass.constantPoolEntriesAccept(this);
-        // Initialize all fields and methods.
-        programClass.fieldsAccept(this);
-        programClass.methodsAccept(this);
-        // Initialize the attributes.
-        programClass.attributesAccept(this);
-    }
-    public void visitLibraryClass(LibraryClass libraryClass)
-    {
-        // Initialize all fields and methods.
-        libraryClass.fieldsAccept(this);
-        libraryClass.methodsAccept(this);
-    }
-    // Implementations for MemberVisitor.
-    public void visitProgramField(ProgramClass programClass, ProgramField programField)
-    {
-        programField.referencedClass =
-            findReferencedClass(programClass.getName(),
-                                programField.getDescriptor(programClass));
-        // Initialize the attributes.
-        programField.attributesAccept(programClass, this);
-    }
-    public void visitProgramMethod(ProgramClass programClass, ProgramMethod programMethod)
-    {
-        programMethod.referencedClasses =
-            findReferencedClasses(programClass.getName(),
-                                  programMethod.getDescriptor(programClass));
-        // Initialize the attributes.
-        programMethod.attributesAccept(programClass, this);
-    }
-    public void visitLibraryField(LibraryClass libraryClass, LibraryField libraryField)
-    {
-        libraryField.referencedClass =
-            findReferencedClass(libraryClass.getName(),
-                                libraryField.getDescriptor(libraryClass));
-    }
-    public void visitLibraryMethod(LibraryClass libraryClass, LibraryMethod libraryMethod)
-    {
-        libraryMethod.referencedClasses =
-            findReferencedClasses(libraryClass.getName(),
-                                  libraryMethod.getDescriptor(libraryClass));
-    }
-    // Implementations for ConstantVisitor.
-    public void visitAnyConstant(Clazz clazz, Constant constant) {}
-    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
-    {
-        // Fill out the String class.
-        stringConstant.javaLangStringClass =
-            findClass(clazz.getName(), ClassConstants.INTERNAL_NAME_JAVA_LANG_STRING);
-    }
-    public void visitMethodHandleConstant(Clazz clazz, MethodHandleConstant methodHandleConstant)
-    {
-        // Fill out the MethodHandle class.
-        methodHandleConstant.javaLangInvokeMethodHandleClass =
-            findClass(clazz.getName(), ClassConstants.INTERNAL_NAME_JAVA_LANG_INVOKE_METHOD_HANDLE);
-    }
-    public void visitAnyRefConstant(Clazz clazz, RefConstant refConstant)
-    {
-        String className = refConstant.getClassName(clazz);
-        // Methods for array types should be found in the Object class.
-        if (ClassUtil.isInternalArrayType(className))
-        {
-            className = ClassConstants.INTERNAL_NAME_JAVA_LANG_OBJECT;
-        }
-        // See if we can find the referenced class.
-        // Unresolved references are assumed to refer to library classes
-        // that will not change anyway.
-        Clazz referencedClass = findClass(clazz.getName(), className);
-        if (referencedClass != null)
-        {
-            String name = refConstant.getName(clazz);
-            String type = refConstant.getType(clazz);
-            boolean isFieldRef = refConstant.getTag() == ClassConstants.CONSTANT_Fieldref;
-            // See if we can find the referenced class member somewhere in the
-            // hierarchy.
-            refConstant.referencedMember = memberFinder.findMember(clazz,
-                                                                   referencedClass,
-                                                                   name,
-                                                                   type,
-                                                                   isFieldRef);
-            refConstant.referencedClass  = memberFinder.correspondingClass();
-            if (refConstant.referencedMember == null)
-            {
-                // We haven't found the class member anywhere in the hierarchy.
-                missingMemberWarningPrinter.print(clazz.getName(),
-                                                  className,
-                                                  "Warning: " +
-                                                  ClassUtil.externalClassName(clazz.getName()) +
-                                                  ": can't find referenced " +
-                                                  (isFieldRef ?
-                                                      "field '"  + ClassUtil.externalFullFieldDescription(0, name, type) :
-                                                      "method '" + ClassUtil.externalFullMethodDescription(className, 0, name, type)) +
-                                                  "' in class " +
-                                                  ClassUtil.externalClassName(className));
-            }
-        }
-    }
-    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
-    {
-        String className = clazz.getName();
-        // Fill out the referenced class.
-        classConstant.referencedClass =
-            findClass(className, ClassUtil.internalClassNameFromClassType(classConstant.getName(clazz)));
-        // Fill out the Class class.
-        classConstant.javaLangClassClass =
-            findClass(className, ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS);
-    }
-    public void visitMethodTypeConstant(Clazz clazz, MethodTypeConstant methodTypeConstant)
-    {
-        // Fill out the MethodType class.
-        methodTypeConstant.javaLangInvokeMethodTypeClass =
-            findClass(clazz.getName(), ClassConstants.INTERNAL_NAME_JAVA_LANG_INVOKE_METHOD_TYPE);
-    }
-    // Implementations for AttributeVisitor.
-    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
-    public void visitEnclosingMethodAttribute(Clazz clazz, EnclosingMethodAttribute enclosingMethodAttribute)
-    {
-        String className          = clazz.getName();
-        String enclosingClassName = enclosingMethodAttribute.getClassName(clazz);
-        // See if we can find the referenced class.
-        enclosingMethodAttribute.referencedClass =
-            findClass(className, enclosingClassName);
-        if (enclosingMethodAttribute.referencedClass != null)
-        {
-            // Is there an enclosing method? Otherwise it's just initialization
-            // code outside of the constructors.
-            if (enclosingMethodAttribute.u2nameAndTypeIndex != 0)
-            {
-                String name = enclosingMethodAttribute.getName(clazz);
-                String type = enclosingMethodAttribute.getType(clazz);
-                // See if we can find the method in the referenced class.
-                enclosingMethodAttribute.referencedMethod =
-                    enclosingMethodAttribute.referencedClass.findMethod(name, type);
-                if (enclosingMethodAttribute.referencedMethod == null)
-                {
-                    // We couldn't find the enclosing method.
-                    missingMemberWarningPrinter.print(className,
-                                                      enclosingClassName,
-                                                      "Warning: " +
-                                                      ClassUtil.externalClassName(className) +
-                                                      ": can't find enclosing method '" +
-                                                      ClassUtil.externalFullMethodDescription(enclosingClassName, 0, name, type) +
-                                                      "' in class " +
-                                                      ClassUtil.externalClassName(enclosingClassName));
-                }
-            }
-        }
-    }
-    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
-    {
-        // Initialize the nested attributes.
-        codeAttribute.attributesAccept(clazz, method, this);
-    }
-    public void visitLocalVariableTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTableAttribute localVariableTableAttribute)
-    {
-        // Initialize the local variables.
-        localVariableTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
-    }
-    public void visitLocalVariableTypeTableAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeTableAttribute localVariableTypeTableAttribute)
-    {
-        // Initialize the local variable types.
-        localVariableTypeTableAttribute.localVariablesAccept(clazz, method, codeAttribute, this);
-    }
-    public void visitSignatureAttribute(Clazz clazz, SignatureAttribute signatureAttribute)
-    {
-        signatureAttribute.referencedClasses =
-            findReferencedClasses(clazz.getName(),
-                                  clazz.getString(signatureAttribute.u2signatureIndex));
-    }
-    public void visitAnyAnnotationsAttribute(Clazz clazz, AnnotationsAttribute annotationsAttribute)
-    {
-        // Initialize the annotations.
-        annotationsAttribute.annotationsAccept(clazz, this);
-    }
-    public void visitAnyParameterAnnotationsAttribute(Clazz clazz, Method method, ParameterAnnotationsAttribute parameterAnnotationsAttribute)
-    {
-        // Initialize the annotations.
-        parameterAnnotationsAttribute.annotationsAccept(clazz, method, this);
-    }
-    public void visitAnnotationDefaultAttribute(Clazz clazz, Method method, AnnotationDefaultAttribute annotationDefaultAttribute)
-    {
-        // Initialize the annotation.
-        annotationDefaultAttribute.defaultValueAccept(clazz, this);
-    }
-    // Implementations for LocalVariableInfoVisitor.
-    public void visitLocalVariableInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableInfo localVariableInfo)
-    {
-        localVariableInfo.referencedClass =
-            findReferencedClass(clazz.getName(),
-                                clazz.getString(localVariableInfo.u2descriptorIndex));
-    }
-    // Implementations for LocalVariableTypeInfoVisitor.
-    public void visitLocalVariableTypeInfo(Clazz clazz, Method method, CodeAttribute codeAttribute, LocalVariableTypeInfo localVariableTypeInfo)
-    {
-        localVariableTypeInfo.referencedClasses =
-            findReferencedClasses(clazz.getName(),
-                                  clazz.getString(localVariableTypeInfo.u2signatureIndex));
-    }
-    // Implementations for AnnotationVisitor.
-    public void visitAnnotation(Clazz clazz, Annotation annotation)
-    {
-        annotation.referencedClasses =
-            findReferencedClasses(clazz.getName(),
-                                  clazz.getString(annotation.u2typeIndex));
-        // Initialize the element values.
-        annotation.elementValuesAccept(clazz, this);
-    }
-    // Implementations for ElementValueVisitor.
-    public void visitConstantElementValue(Clazz clazz, Annotation annotation, ConstantElementValue constantElementValue)
-    {
-        initializeElementValue(clazz, annotation, constantElementValue);
-    }
-    public void visitEnumConstantElementValue(Clazz clazz, Annotation annotation, EnumConstantElementValue enumConstantElementValue)
-    {
-        initializeElementValue(clazz, annotation, enumConstantElementValue);
-        enumConstantElementValue.referencedClasses =
-            findReferencedClasses(clazz.getName(),
-                                  clazz.getString(enumConstantElementValue.u2typeNameIndex));
-    }
-    public void visitClassElementValue(Clazz clazz, Annotation annotation, ClassElementValue classElementValue)
-    {
-        initializeElementValue(clazz, annotation, classElementValue);
-        classElementValue.referencedClasses =
-            findReferencedClasses(clazz.getName(),
-                                  clazz.getString(classElementValue.u2classInfoIndex));
-    }
-    public void visitAnnotationElementValue(Clazz clazz, Annotation annotation, AnnotationElementValue annotationElementValue)
-    {
-        initializeElementValue(clazz, annotation, annotationElementValue);
-        // Initialize the annotation.
-        annotationElementValue.annotationAccept(clazz, this);
-    }
-    public void visitArrayElementValue(Clazz clazz, Annotation annotation, ArrayElementValue arrayElementValue)
-    {
-        initializeElementValue(clazz, annotation, arrayElementValue);
-        // Initialize the element values.
-        arrayElementValue.elementValuesAccept(clazz, annotation, this);
-    }
-    /**
-     * Initializes the referenced method of an element value, if any.
-     */
-    private void initializeElementValue(Clazz clazz, Annotation annotation, ElementValue elementValue)
-    {
-        // See if we have a referenced class.
-        if (annotation                      != null &&
-            annotation.referencedClasses    != null &&
-            elementValue.u2elementNameIndex != 0)
-        {
-            // See if we can find the method in the referenced class
-            // (ignoring the descriptor).
-            String name = clazz.getString(elementValue.u2elementNameIndex);
-            Clazz referencedClass = annotation.referencedClasses[0];
-            elementValue.referencedClass  = referencedClass;
-            elementValue.referencedMethod = referencedClass.findMethod(name, null);
-        }
-    }
-    // Small utility methods.
-    /**
-     * Returns the single class referenced by the given descriptor, or
-     * <code>null</code> if there isn't any useful reference.
-     */
-    private Clazz findReferencedClass(String referencingClassName,
-                                      String descriptor)
-    {
-        DescriptorClassEnumeration enumeration =
-            new DescriptorClassEnumeration(descriptor);
-        enumeration.nextFluff();
-        if (enumeration.hasMoreClassNames())
-        {
-            return findClass(referencingClassName, enumeration.nextClassName());
-        }
-        return null;
-    }
-    /**
-     * Returns an array of classes referenced by the given descriptor, or
-     * <code>null</code> if there aren't any useful references.
-     */
-    private Clazz[] findReferencedClasses(String referencingClassName,
-                                          String descriptor)
-    {
-        DescriptorClassEnumeration enumeration =
-            new DescriptorClassEnumeration(descriptor);
-        int classCount = enumeration.classCount();
-        if (classCount > 0)
-        {
-            Clazz[] referencedClasses = new Clazz[classCount];
-            boolean foundReferencedClasses = false;
-            for (int index = 0; index < classCount; index++)
-            {
-                String fluff = enumeration.nextFluff();
-                String name  = enumeration.nextClassName();
-                Clazz referencedClass = findClass(referencingClassName, name);
-                if (referencedClass != null)
-                {
-                    referencedClasses[index] = referencedClass;
-                    foundReferencedClasses = true;
-                }
-            }
-            if (foundReferencedClasses)
-            {
-                return referencedClasses;
-            }
-        }
-        return null;
-    }
-    /**
-     * Returns the class with the given name, either for the program class pool
-     * or from the library class pool, or <code>null</code> if it can't be found.
-     */
-    private Clazz findClass(String referencingClassName, String name)
-    {
-        // Is it an array type?
-        if (ClassUtil.isInternalArrayType(name))
-        {
-            // Ignore any primitive array types.
-            if (!ClassUtil.isInternalClassType(name))
-            {
-                return null;
-            }
-            // Strip the array part.
-            name = ClassUtil.internalClassNameFromClassType(name);
-        }
-        // First look for the class in the program class pool.
-        Clazz clazz = programClassPool.getClass(name);
-        // Otherwise look for the class in the library class pool.
-        if (clazz == null)
-        {
-            clazz = libraryClassPool.getClass(name);
-            if (clazz == null &&
-                missingClassWarningPrinter != null)
-            {
-                // We didn't find the superclass or interface. Print a warning.
-                missingClassWarningPrinter.print(referencingClassName,
-                                                 name,
-                                                 "Warning: " +
-                                                 ClassUtil.externalClassName(referencingClassName) +
-                                                 ": can't find referenced class " +
-                                                 ClassUtil.externalClassName(name));
-            }
-        }
-        else if (dependencyWarningPrinter != null)
-        {
-            // The superclass or interface was found in the program class pool.
-            // Print a warning.
-            dependencyWarningPrinter.print(referencingClassName,
-                                           name,
-                                           "Warning: library class " +
-                                           ClassUtil.externalClassName(referencingClassName) +
-                                           " depends on program class " +
-                                           ClassUtil.externalClassName(name));
-        }
-        return clazz;
-    }
-}