sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/classfile/Clazz.java

@@ -0,0 +1,261 @@
+/*
+ * 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;
+
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.visitor.*;
+
+
+/**
+ * This interface provides access to the representation of a Java class.
+ *
+ * @author Eric Lafortune
+ */
+public interface Clazz extends VisitorAccepter
+{
+    /**
+     * Returns the access flags of this class.
+     * @see ClassConstants
+     */
+    public int getAccessFlags();
+
+    /**
+     * Returns the full internal name of this class.
+     */
+    public String getName();
+
+    /**
+     * Returns the full internal name of the super class of this class, or
+     * null if this class represents java.lang.Object.
+     */
+    public String getSuperName();
+
+    /**
+     * Returns the number of interfaces that this class implements.
+     */
+    public int getInterfaceCount();
+
+    /**
+     * Returns the full internal name of the interface at the given index of
+     * this class.
+     */
+    public String getInterfaceName(int index);
+
+    /**
+     * Returns the tag value of the Constant at the specified index.
+     */
+    public int getTag(int constantIndex);
+
+    /**
+     * Returns the String value of the Utf8Constant at the specified index.
+     */
+    public String getString(int constantIndex);
+
+    /**
+     * Returns the String value of the StringConstant at the specified index.
+     */
+    public String getStringString(int constantIndex);
+
+    /**
+     * Returns the class name of ClassConstant at the specified index.
+     */
+    public String getClassName(int constantIndex);
+
+    /**
+     * Returns the name of the NameAndTypeConstant at the specified index.
+     */
+    public String getName(int constantIndex);
+
+    /**
+     * Returns the type of the NameAndTypeConstant at the specified index.
+     */
+    public String getType(int constantIndex);
+
+    /**
+     * Returns the name of the RefConstant at the specified index.
+     */
+    public String getRefName(int constantIndex);
+
+    /**
+     * Returns the type of the RefConstant at the specified index.
+     */
+    public String getRefType(int constantIndex);
+
+
+    // Methods pertaining to related classes.
+
+    /**
+     * Notifies this Clazz that it is being subclassed by another class.
+     */
+    public void addSubClass(Clazz clazz);
+
+    /**
+     * Returns the super class of this class.
+     */
+    public Clazz getSuperClass();
+
+    /**
+     * Returns the interface at the given index.
+     */
+    public Clazz getInterface(int index);
+
+    /**
+     * Returns whether this class extends the given class.
+     * A class is always considered to extend itself.
+     * Interfaces are considered to only extend the root Object class.
+     */
+    public boolean extends_(Clazz clazz);
+
+    /**
+     * Returns whether this class extends the specified class.
+     * A class is always considered to extend itself.
+     * Interfaces are considered to only extend the root Object class.
+     */
+    public boolean extends_(String className);
+
+    /**
+     * Returns whether this class implements the given class.
+     * A class is always considered to implement itself.
+     * Interfaces are considered to implement all their superinterfaces.
+     */
+    public boolean extendsOrImplements(Clazz clazz);
+
+    /**
+     * Returns whether this class implements the specified class.
+     * A class is always considered to implement itself.
+     * Interfaces are considered to implement all their superinterfaces.
+     */
+    public boolean extendsOrImplements(String className);
+
+
+    // Methods for getting specific class members.
+
+    /**
+     * Returns the field with the given name and descriptor.
+     */
+    Field findField(String name, String descriptor);
+
+    /**
+     * Returns the method with the given name and descriptor.
+     */
+    Method findMethod(String name, String descriptor);
+
+
+    // Methods for accepting various types of visitors.
+
+    /**
+     * Accepts the given class visitor.
+     */
+    public void accept(ClassVisitor classVisitor);
+
+    /**
+     * Accepts the given class visitor in the class hierarchy.
+     * @param visitThisClass   specifies whether to visit this class.
+     * @param visitSuperClass  specifies whether to visit the super classes.
+     * @param visitInterfaces  specifies whether to visit the interfaces.
+     * @param visitSubclasses  specifies whether to visit the subclasses.
+     * @param classVisitor     the <code>ClassVisitor</code> that will
+     *                         visit the class hierarchy.
+     */
+    public void hierarchyAccept(boolean      visitThisClass,
+                                boolean      visitSuperClass,
+                                boolean      visitInterfaces,
+                                boolean      visitSubclasses,
+                                ClassVisitor classVisitor);
+
+    /**
+     * Lets the given class visitor visit all known subclasses.
+     * @param classVisitor the <code>ClassVisitor</code> that will visit the
+     *                     subclasses.
+     */
+    public void subclassesAccept(ClassVisitor classVisitor);
+
+    /**
+     * Lets the given constant pool entry visitor visit all constant pool entries
+     * of this class.
+     */
+    public void constantPoolEntriesAccept(ConstantVisitor constantVisitor);
+
+    /**
+     * Lets the given constant pool entry visitor visit the constant pool entry
+     * at the specified index.
+     */
+    public void constantPoolEntryAccept(int index, ConstantVisitor constantVisitor);
+
+    /**
+     * Lets the given constant pool entry visitor visit the class constant pool
+     * entry of this class.
+     */
+    public void thisClassConstantAccept(ConstantVisitor constantVisitor);
+
+    /**
+     * Lets the given constant pool entry visitor visit the class constant pool
+     * entry of the super class of this class, if there is one.
+     */
+    public void superClassConstantAccept(ConstantVisitor constantVisitor);
+
+    /**
+     * Lets the given constant pool entry visitor visit the class constant pool
+     * entries for all interfaces of this class.
+     */
+    public void interfaceConstantsAccept(ConstantVisitor constantVisitor);
+
+    /**
+     * Lets the given member info visitor visit all fields of this class.
+     */
+    public void fieldsAccept(MemberVisitor memberVisitor);
+
+    /**
+     * Lets the given member info visitor visit the specified field.
+     */
+    public void fieldAccept(String name, String descriptor, MemberVisitor memberVisitor);
+
+    /**
+     * Lets the given member info visitor visit all methods of this class.
+     */
+    public void methodsAccept(MemberVisitor memberVisitor);
+
+    /**
+     * Lets the given member info visitor visit the specified method.
+     */
+    public void methodAccept(String name, String descriptor, MemberVisitor memberVisitor);
+
+    /**
+     * Returns whether the given method may possibly have implementing or
+     * overriding methods down the class hierarchy. This can only be true
+     * if the class is not final, and the method is not private, static, or
+     * final, or a constructor.
+     * @param method the method that may have implementations.
+     * @return whether it may have implementations.
+     */
+    public boolean mayHaveImplementations(Method method);
+
+    /**
+     * Lets the given attribute info visitor visit all attributes of this class.
+     */
+    public void attributesAccept(AttributeVisitor attributeVisitor);
+
+    /**
+     * Lets the given attribute info visitor visit the specified attribute.
+     */
+    public void attributeAccept(String name, AttributeVisitor attributeVisitor);
+}

data/lib/proguard4.7/src/proguard/classfile/Field.java

@@ -0,0 +1,32 @@
+/*
+ * 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;
+
+
+
+/**
+ * Representation of a field from a class.
+ *
+ * @author Eric Lafortune
+ */
+public interface Field extends Member
+{
+}

data/lib/proguard4.7/src/proguard/classfile/LibraryClass.java

@@ -0,0 +1,548 @@
+/*
+ * 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;
+
+import proguard.classfile.attribute.visitor.AttributeVisitor;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.util.*;
+import proguard.classfile.visitor.*;
+
+/**
+ * This Clazz is a compact representation of the essential data in a Java class.
+ *
+ * @author Eric Lafortune
+ */
+public class LibraryClass implements Clazz
+{
+    public int             u2accessFlags;
+    public String          thisClassName;
+    public String          superClassName;
+    public String[]        interfaceNames;
+    public LibraryField[]  fields;
+    public LibraryMethod[] methods;
+
+    /**
+     * An extra field pointing to the superclass of this class.
+     * This field is filled out by the {@link ClassSuperHierarchyInitializer}.
+     */
+    public Clazz   superClass;
+
+    /**
+     * An extra field pointing to the interfaces of this class.
+     * This field is filled out by the {@link ClassSuperHierarchyInitializer}.
+     */
+    public Clazz[] interfaceClasses;
+
+    /**
+     * An extra field pointing to the subclasses of this class.
+     * This field is filled out by the {@link ClassSubHierarchyInitializer}.
+     */
+    public Clazz[] subClasses;
+
+    /**
+     * An extra field in which visitors can store information.
+     */
+    public Object visitorInfo;
+
+
+    /**
+     * Creates an empty LibraryClass.
+     */
+    public LibraryClass() {}
+
+
+    /**
+     * Returns whether this library class is visible to the outside world.
+     */
+    boolean isVisible()
+    {
+        return (u2accessFlags & ClassConstants.INTERNAL_ACC_PUBLIC) != 0;
+    }
+
+
+    // Implementations for Clazz.
+
+    public int getAccessFlags()
+    {
+        return u2accessFlags;
+    }
+
+    public String getName()
+    {
+        return thisClassName;
+    }
+
+    public String getSuperName()
+    {
+        // This may be java/lang/Object, in which case there is no super.
+        return superClassName;
+    }
+
+    public int getInterfaceCount()
+    {
+        return interfaceClasses.length;
+    }
+
+    public String getInterfaceName(int index)
+    {
+        return interfaceNames[index];
+    }
+
+    public int getTag(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+    public String getString(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+    public String getStringString(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+    public String getClassName(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+    public String getName(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+    public String getType(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+
+    public String getRefName(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+    public String getRefType(int constantIndex)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store constant pool");
+    }
+
+
+    public void addSubClass(Clazz clazz)
+    {
+        if (subClasses == null)
+        {
+            subClasses = new Clazz[1];
+        }
+        else
+        {
+            // Copy the old elements into new larger array.
+            Clazz[] temp     = new Clazz[subClasses.length+1];
+            System.arraycopy(subClasses, 0, temp, 0, subClasses.length);
+            subClasses = temp;
+        }
+
+        subClasses[subClasses.length-1] = clazz;
+    }
+
+
+    public Clazz getSuperClass()
+    {
+        return superClass;
+    }
+
+
+    public Clazz getInterface(int index)
+    {
+        return interfaceClasses[index];
+    }
+
+
+    public boolean extends_(Clazz clazz)
+    {
+        if (this.equals(clazz))
+        {
+            return true;
+        }
+
+        return superClass != null &&
+               superClass.extends_(clazz);
+    }
+
+
+    public boolean extends_(String className)
+    {
+        if (getName().equals(className))
+        {
+            return true;
+        }
+
+        return superClass != null &&
+               superClass.extends_(className);
+    }
+
+
+    public boolean extendsOrImplements(Clazz clazz)
+    {
+        if (this.equals(clazz))
+        {
+            return true;
+        }
+
+        if (superClass != null &&
+            superClass.extendsOrImplements(clazz))
+        {
+            return true;
+        }
+
+        if (interfaceClasses != null)
+        {
+            for (int index = 0; index < interfaceClasses.length; index++)
+            {
+                Clazz interfaceClass = interfaceClasses[index];
+                if (interfaceClass != null &&
+                    interfaceClass.extendsOrImplements(clazz))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+
+    public boolean extendsOrImplements(String className)
+    {
+        if (getName().equals(className))
+        {
+            return true;
+        }
+
+        if (superClass != null &&
+            superClass.extendsOrImplements(className))
+        {
+            return true;
+        }
+
+        if (interfaceClasses != null)
+        {
+            for (int index = 0; index < interfaceClasses.length; index++)
+            {
+                Clazz interfaceClass = interfaceClasses[index];
+                if (interfaceClass != null &&
+                    interfaceClass.extendsOrImplements(className))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+
+    public Field findField(String name, String descriptor)
+    {
+        for (int index = 0; index < fields.length; index++)
+        {
+            Field field = fields[index];
+            if (field != null &&
+                (name       == null || field.getName(this).equals(name)) &&
+                (descriptor == null || field.getDescriptor(this).equals(descriptor)))
+            {
+                return field;
+            }
+        }
+
+        return null;
+    }
+
+
+    public Method findMethod(String name, String descriptor)
+    {
+        for (int index = 0; index < methods.length; index++)
+        {
+            Method method = methods[index];
+            if (method != null &&
+                (name       == null || method.getName(this).equals(name)) &&
+                (descriptor == null || method.getDescriptor(this).equals(descriptor)))
+            {
+                return method;
+            }
+        }
+
+        return null;
+    }
+
+
+    public void accept(ClassVisitor classVisitor)
+    {
+        classVisitor.visitLibraryClass(this);
+    }
+
+
+    public void hierarchyAccept(boolean      visitThisClass,
+                                boolean      visitSuperClass,
+                                boolean      visitInterfaces,
+                                boolean      visitSubclasses,
+                                ClassVisitor classVisitor)
+    {
+        // First visit the current classfile.
+        if (visitThisClass)
+        {
+            accept(classVisitor);
+        }
+
+        // Then visit its superclass, recursively.
+        if (visitSuperClass)
+        {
+            if (superClass != null)
+            {
+                superClass.hierarchyAccept(true,
+                                           true,
+                                           visitInterfaces,
+                                           false,
+                                           classVisitor);
+            }
+        }
+
+        // Then visit its interfaces, recursively.
+        if (visitInterfaces)
+        {
+            // Visit the interfaces of the superclasses, if we haven't done so yet.
+            if (!visitSuperClass)
+            {
+                if (superClass != null)
+                {
+                    superClass.hierarchyAccept(false,
+                                               false,
+                                               true,
+                                               false,
+                                               classVisitor);
+                }
+            }
+
+            // Visit the interfaces.
+            if (interfaceClasses != null)
+            {
+                for (int index = 0; index < interfaceClasses.length; index++)
+                {
+                    Clazz interfaceClass = interfaceClasses[index];
+                    if (interfaceClass != null)
+                    {
+                        interfaceClass.hierarchyAccept(true,
+                                                       false,
+                                                       true,
+                                                       false,
+                                                       classVisitor);
+                    }
+                }
+            }
+        }
+
+        // Then visit its subclasses, recursively.
+        if (visitSubclasses)
+        {
+            if (subClasses != null)
+            {
+                for (int index = 0; index < subClasses.length; index++)
+                {
+                    subClasses[index].hierarchyAccept(true,
+                                                      false,
+                                                      false,
+                                                      true,
+                                                      classVisitor);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Lets the given class visitor visit the superclass, if it is known.
+     * @param classVisitor the <code>ClassVisitor</code> that will visit the
+     *                     superclass.
+     */
+    public void superClassAccept(ClassVisitor classVisitor)
+    {
+        if (superClass != null)
+        {
+            superClass.accept(classVisitor);
+        }
+    }
+
+
+    /**
+     * Lets the given class visitor visit all known direct interfaces.
+     * @param classVisitor the <code>ClassVisitor</code> that will visit the
+     *                     interfaces.
+     */
+    public void interfacesAccept(ClassVisitor classVisitor)
+    {
+        if (interfaceClasses != null)
+        {
+            for (int index = 0; index < interfaceClasses.length; index++)
+            {
+                Clazz interfaceClass = interfaceClasses[index];
+                if (interfaceClass != null)
+                {
+                    interfaceClass.accept(classVisitor);
+                }
+            }
+        }
+    }
+
+
+    public void subclassesAccept(ClassVisitor classVisitor)
+    {
+        if (subClasses != null)
+        {
+            for (int index = 0; index < subClasses.length; index++)
+            {
+                subClasses[index].accept(classVisitor);
+            }
+        }
+    }
+
+
+    public void constantPoolEntriesAccept(ConstantVisitor constantVisitor)
+    {
+        // This class doesn't keep references to its constant pool entries.
+    }
+
+
+    public void constantPoolEntryAccept(int index, ConstantVisitor constantVisitor)
+    {
+        // This class doesn't keep references to its constant pool entries.
+    }
+
+
+    public void thisClassConstantAccept(ConstantVisitor constantVisitor)
+    {
+        // This class doesn't keep references to its constant pool entries.
+    }
+
+
+    public void superClassConstantAccept(ConstantVisitor constantVisitor)
+    {
+        // This class doesn't keep references to its constant pool entries.
+    }
+
+
+    public void interfaceConstantsAccept(ConstantVisitor constantVisitor)
+    {
+        // This class doesn't keep references to its constant pool entries.
+    }
+
+
+    public void fieldsAccept(MemberVisitor memberVisitor)
+    {
+        for (int index = 0; index < fields.length; index++)
+        {
+            Field field = fields[index];
+            if (field != null)
+            {
+                field.accept(this, memberVisitor);
+            }
+        }
+    }
+
+
+    public void fieldAccept(String name, String descriptor, MemberVisitor memberVisitor)
+    {
+        Field field = findField(name, descriptor);
+        if (field != null)
+        {
+            field.accept(this, memberVisitor);
+        }
+    }
+
+
+    public void methodsAccept(MemberVisitor memberVisitor)
+    {
+        for (int index = 0; index < methods.length; index++)
+        {
+            Method method = methods[index];
+            if (method != null)
+            {
+                method.accept(this, memberVisitor);
+            }
+        }
+    }
+
+
+    public void methodAccept(String name, String descriptor, MemberVisitor memberVisitor)
+    {
+        Method method = findMethod(name, descriptor);
+        if (method != null)
+        {
+            method.accept(this, memberVisitor);
+        }
+    }
+
+
+    public boolean mayHaveImplementations(Method method)
+    {
+        return
+           (u2accessFlags & ClassConstants.INTERNAL_ACC_FINAL) == 0 &&
+           (method == null ||
+            ((method.getAccessFlags() & (ClassConstants.INTERNAL_ACC_PRIVATE |
+                                         ClassConstants.INTERNAL_ACC_STATIC  |
+                                         ClassConstants.INTERNAL_ACC_FINAL)) == 0 &&
+                                                                                  !method.getName(this).equals(ClassConstants.INTERNAL_METHOD_NAME_INIT)));
+    }
+
+
+    public void attributesAccept(AttributeVisitor attributeVisitor)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store attributes");
+    }
+
+
+    public void attributeAccept(String name, AttributeVisitor attributeVisitor)
+    {
+        throw new UnsupportedOperationException("Library class ["+thisClassName+"] doesn't store attributes");
+    }
+
+
+    // Implementations for VisitorAccepter.
+
+    public Object getVisitorInfo()
+    {
+        return visitorInfo;
+    }
+
+    public void setVisitorInfo(Object visitorInfo)
+    {
+        this.visitorInfo = visitorInfo;
+    }
+
+
+    // Implementations for Object.
+
+    public String toString()
+    {
+        return "LibraryClass("+getName()+")";
+    }
+}