sometsome 1.0.2 → 3.10.42

data/lib/proguard4.7/src/proguard/classfile/util/InternalTypeEnumeration.java

@@ -0,0 +1,204 @@
+/*
+ * 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;
+
+
+/**
+ * An <code>InternalTypeEnumeration</code> provides an enumeration of all
+ * parameter types listed in a given internal method descriptor or signature.
+ * The signature can also be a class signature. The return type of a method
+ * descriptor can retrieved separately.
+ *
+ * @author Eric Lafortune
+ */
+public class InternalTypeEnumeration
+{
+    private String descriptor;
+    private int    firstIndex;
+    private int    lastIndex;
+    private int    index;
+
+
+    /**
+     * Creates a new InternalTypeEnumeration for the given method descriptor.
+     */
+    public InternalTypeEnumeration(String descriptor)
+    {
+        this.descriptor = descriptor;
+        this.firstIndex = descriptor.indexOf(ClassConstants.INTERNAL_METHOD_ARGUMENTS_OPEN);
+        this.lastIndex  = descriptor.indexOf(ClassConstants.INTERNAL_METHOD_ARGUMENTS_CLOSE);
+        this.index      = firstIndex + 1;
+
+        if (lastIndex < 0)
+        {
+            lastIndex = descriptor.length();
+        }
+    }
+
+
+    /**
+     * Returns the formal type parameters from the descriptor, assuming it's a
+     * method descriptor.
+     */
+    public String formalTypeParameters()
+    {
+        return descriptor.substring(0, firstIndex);
+    }
+
+
+    /**
+     * Returns whether the enumeration can provide more types from the method
+     * descriptor.
+     */
+    public boolean hasMoreTypes()
+    {
+        return index < lastIndex;
+    }
+
+
+    /**
+     * Returns the next type from the method descriptor.
+     */
+    public String nextType()
+    {
+        int startIndex = index;
+
+        skipArray();
+
+        char c = descriptor.charAt(index++);
+        switch (c)
+        {
+            case ClassConstants.INTERNAL_TYPE_CLASS_START:
+            case ClassConstants.INTERNAL_TYPE_GENERIC_VARIABLE_START:
+            {
+                skipClass();
+                break;
+            }
+            case ClassConstants.INTERNAL_TYPE_GENERIC_START:
+            {
+                skipGeneric();
+                break;
+            }
+        }
+
+        return descriptor.substring(startIndex, index);
+    }
+
+
+    /**
+     * Returns the return type from the descriptor, assuming it's a method
+     * descriptor.
+     */
+    public String returnType()
+    {
+        return descriptor.substring(lastIndex + 1);
+    }
+
+
+    // Small utility methods.
+
+    private void skipArray()
+    {
+        while (descriptor.charAt(index) == ClassConstants.INTERNAL_TYPE_ARRAY)
+        {
+            index++;
+        }
+    }
+
+
+    private void skipClass()
+    {
+        while (true)
+        {
+            char c = descriptor.charAt(index++);
+            switch (c)
+            {
+                case ClassConstants.INTERNAL_TYPE_GENERIC_START:
+                    skipGeneric();
+                    break;
+
+                case ClassConstants.INTERNAL_TYPE_CLASS_END:
+                    return;
+            }
+        }
+    }
+
+
+    private void skipGeneric()
+    {
+        int nestingLevel = 1;
+
+        do
+        {
+            char c = descriptor.charAt(index++);
+            switch (c)
+            {
+                case ClassConstants.INTERNAL_TYPE_GENERIC_START:
+                    nestingLevel++;
+                    break;
+
+                case ClassConstants.INTERNAL_TYPE_GENERIC_END:
+                    nestingLevel--;
+                    break;
+            }
+        }
+        while (nestingLevel > 0);
+    }
+
+
+    /**
+     * A main method for testing the type enumeration.
+     */
+    public static void main(String[] args)
+    {
+        try
+        {
+            for (int index = 0; index < args.length; index++)
+            {
+                String descriptor = args[index];
+
+                System.out.println("Descriptor ["+descriptor+"]");
+                InternalTypeEnumeration enumeration = new InternalTypeEnumeration(descriptor);
+
+                if (enumeration.firstIndex >= 0)
+                {
+                    System.out.println("  Formal type parameters ["+enumeration.formalTypeParameters()+"]");
+                }
+
+                while (enumeration.hasMoreTypes())
+                {
+                    System.out.println("  Type ["+enumeration.nextType()+"]");
+                }
+
+                if (enumeration.lastIndex < descriptor.length())
+                {
+                    System.out.println("  Return type ["+enumeration.returnType()+"]");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/util/MemberFinder.java

@@ -0,0 +1,197 @@
+/*
+ * 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.visitor.*;
+
+/**
+ * This class provides methods to find class members in a given class or in its
+ * hierarchy.
+ *
+ * @author Eric Lafortune
+ */
+public class MemberFinder
+extends      SimplifiedVisitor
+implements   MemberVisitor
+{
+    private static class MemberFoundException extends RuntimeException {}
+    private static final MemberFoundException MEMBER_FOUND = new MemberFoundException();
+
+    private Clazz  clazz;
+    private Member member;
+
+
+    /**
+     * Finds the field with the given name and descriptor in the given
+     * class or its hierarchy.
+     */
+    public Field findField(Clazz  referencingClass,
+                           Clazz  clazz,
+                           String name,
+                           String descriptor)
+    {
+        return (Field)findMember(referencingClass, clazz, name, descriptor, true);
+    }
+
+
+    /**
+     * Finds the method with the given name and descriptor in the given
+     * class or its hierarchy.
+     */
+    public Method findMethod(Clazz  referencingClass,
+                             Clazz  clazz,
+                             String name,
+                             String descriptor)
+    {
+        return (Method)findMember(referencingClass, clazz, name, descriptor, false);
+    }
+
+
+    /**
+     * Finds the class member with the given name and descriptor in the given
+     * class or its hierarchy.
+     */
+    public Member findMember(Clazz   referencingClass,
+                             Clazz   clazz,
+                             String  name,
+                             String  descriptor,
+                             boolean isField)
+    {
+        // Organize a search in the hierarchy of superclasses and interfaces.
+        // The class member may be in a different class, if the code was
+        // compiled with "-target 1.2" or higher (the default in JDK 1.4).
+        try
+        {
+            this.clazz  = null;
+            this.member = null;
+            clazz.hierarchyAccept(true, true, true, false, isField ?
+                (ClassVisitor)new NamedFieldVisitor(name, descriptor,
+                              new MemberClassAccessFilter(referencingClass, this)) :
+                (ClassVisitor)new NamedMethodVisitor(name, descriptor,
+                              new MemberClassAccessFilter(referencingClass, this)));
+        }
+        catch (MemberFoundException ex)
+        {
+            // We've found the member we were looking for.
+        }
+
+        return member;
+    }
+
+
+    /**
+     * Returns the corresponding class of the most recently found class
+     * member.
+     */
+    public Clazz correspondingClass()
+    {
+        return clazz;
+    }
+
+
+    /**
+     * Returns whether the given method is overridden anywhere down the class
+     * hierarchy.
+     */
+    public boolean isOverriden(Clazz  clazz,
+                               Method method)
+    {
+        String name       = method.getName(clazz);
+        String descriptor = method.getDescriptor(clazz);
+
+        // Go looking for the method down the class hierarchy.
+        try
+        {
+            this.clazz  = null;
+            this.member = null;
+
+            clazz.hierarchyAccept(false, false, false, true,
+                new NamedMethodVisitor(name, descriptor,
+                new MemberAccessFilter(0, ClassConstants.INTERNAL_ACC_PRIVATE, this)));
+        }
+        catch (MemberFoundException ex)
+        {
+            // We've found an overriding method.
+            return true;
+        }
+
+        return false;
+    }
+
+
+    /**
+     * Returns whether the given field is shadowed anywhere down the class
+     * hierarchy.
+     */
+    public boolean isShadowed(Clazz clazz,
+                              Field field)
+    {
+        String name       = field.getName(clazz);
+        String descriptor = field.getDescriptor(clazz);
+
+        // Go looking for the field down the class hierarchy.
+        try
+        {
+            this.clazz  = null;
+            this.member = null;
+            clazz.hierarchyAccept(false, false, false, true,
+                new NamedFieldVisitor(name, descriptor,
+                new MemberAccessFilter(0, ClassConstants.INTERNAL_ACC_PRIVATE, this)));
+        }
+        catch (MemberFoundException ex)
+        {
+            // We've found a shadowing field.
+            return true;
+        }
+
+        return false;
+    }
+
+
+//    // Implementations for ClassVisitor.
+//
+//    private void visitAnyClass(Clazz clazz)
+//    {
+//        if (member == null)
+//        {
+//            member = isField ?
+//                (Member)clazz.findField(name, descriptor) :
+//                (Member)clazz.findMethod(name, descriptor);
+//
+//            if (member != null)
+//            {
+//                this.clazz = clazz;
+//            }
+//        }
+//    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitAnyMember(Clazz clazz, Member member)
+    {
+        this.clazz  = clazz;
+        this.member = member;
+
+        throw MEMBER_FOUND;
+    }
+}

data/lib/proguard4.7/src/proguard/classfile/util/MethodLinker.java

@@ -0,0 +1,160 @@
+/*
+ * 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.visitor.*;
+
+import java.util.*;
+
+/**
+ * This ClassVisitor links all corresponding non-private, non-static,
+ * non-initializer methods in the class hierarchies of all visited classes.
+ * Visited classes are typically all class files that are not being subclassed.
+ * Chains of links that have been created in previous invocations are merged
+ * with new chains of links, in order to create a consistent set of chains.
+ *
+ * @author Eric Lafortune
+ */
+public class MethodLinker
+extends      SimplifiedVisitor
+implements   ClassVisitor,
+             MemberVisitor
+{
+    // An object that is reset and reused every time.
+    // The map: [class member name+' '+descriptor - class member info]
+    private final Map memberMap = new HashMap();
+
+
+    // Implementations for ClassVisitor.
+
+    public void visitAnyClass(Clazz clazz)
+    {
+        // Collect all non-private members in this class hierarchy.
+        clazz.hierarchyAccept(true, true, true, false,
+            new AllMethodVisitor(
+            new MemberAccessFilter(0, ClassConstants.INTERNAL_ACC_PRIVATE | ClassConstants.INTERNAL_ACC_STATIC,
+            this)));
+
+        // Clean up for the next class hierarchy.
+        memberMap.clear();
+    }
+
+
+    // Implementations for MemberVisitor.
+
+    public void visitAnyMember(Clazz clazz, Member member)
+    {
+        // Get the class member's name and descriptor.
+        String name       = member.getName(clazz);
+        String descriptor = member.getDescriptor(clazz);
+
+        // Special cases: <clinit> and <init> are always kept unchanged.
+        // We can ignore them here.
+        if (name.equals(ClassConstants.INTERNAL_METHOD_NAME_CLINIT) ||
+            name.equals(ClassConstants.INTERNAL_METHOD_NAME_INIT))
+        {
+            return;
+        }
+
+        // See if we've already come across a method with the same name and
+        // descriptor.
+        String key = name + ' ' + descriptor;
+        Member otherMember = (Member)memberMap.get(key);
+
+        if (otherMember == null)
+        {
+            // Get the last method in the chain.
+            Member thisLastMember = lastMember(member);
+
+            // Store the new class method in the map.
+            memberMap.put(key, thisLastMember);
+        }
+        else
+        {
+            // Link both members.
+            link(member, otherMember);
+        }
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Links the two given class members.
+     */
+    private static void link(Member member1, Member member2)
+    {
+        // Get the last methods in the both chains.
+        Member lastMember1 = lastMember(member1);
+        Member lastMember2 = lastMember(member2);
+
+        // Check if both link chains aren't already ending in the same element.
+        if (!lastMember1.equals(lastMember2))
+        {
+            // Merge the two chains, with the library members last.
+            if (lastMember2 instanceof LibraryMember)
+            {
+                lastMember1.setVisitorInfo(lastMember2);
+            }
+            else
+            {
+                lastMember2.setVisitorInfo(lastMember1);
+            }
+        }
+    }
+
+
+    /**
+     * Finds the last class member in the linked list of related class members.
+     * @param member the given class member.
+     * @return the last class member in the linked list.
+     */
+    public static Member lastMember(Member member)
+    {
+        Member lastMember = member;
+        while (lastMember.getVisitorInfo() != null &&
+               lastMember.getVisitorInfo() instanceof Member)
+        {
+            lastMember = (Member)lastMember.getVisitorInfo();
+        }
+
+        return lastMember;
+    }
+
+
+    /**
+     * Finds the last visitor accepter in the linked list of visitors.
+     * @param visitorAccepter the given method.
+     * @return the last method in the linked list.
+     */
+    public static VisitorAccepter lastVisitorAccepter(VisitorAccepter visitorAccepter)
+    {
+        VisitorAccepter lastVisitorAccepter = visitorAccepter;
+        while (lastVisitorAccepter.getVisitorInfo() != null &&
+               lastVisitorAccepter.getVisitorInfo() instanceof VisitorAccepter)
+        {
+            lastVisitorAccepter = (VisitorAccepter)lastVisitorAccepter.getVisitorInfo();
+        }
+
+        return lastVisitorAccepter;
+    }
+}