sometsome 1.0.2 → 3.10.42

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

@@ -0,0 +1,236 @@
+/*
+ * 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;
+
+import java.util.Stack;
+
+/**
+ * A <code>DescriptorClassEnumeration</code> provides an enumeration of all
+ * classes mentioned in a given descriptor or signature.
+ *
+ * @author Eric Lafortune
+ */
+public class DescriptorClassEnumeration
+{
+    private String  descriptor;
+
+    private int     index;
+    private int     nestingLevel;
+    private boolean isInnerClassName;
+    private String  accumulatedClassName;
+    private Stack   accumulatedClassNames;
+
+
+    /**
+     * Creates a new DescriptorClassEnumeration for the given descriptor.
+     */
+    public DescriptorClassEnumeration(String descriptor)
+    {
+        this.descriptor = descriptor;
+    }
+
+
+    /**
+     * Returns the number of classes contained in the descriptor. This
+     * is the number of class names that the enumeration will return.
+     */
+    public int classCount()
+    {
+        int count = 0;
+
+        nextFluff();
+        while (hasMoreClassNames())
+        {
+            count++;
+
+            nextClassName();
+            nextFluff();
+        }
+
+        index = 0;
+
+        return count;
+    }
+
+
+    /**
+     * Returns whether the enumeration can provide more class names from the
+     * descriptor.
+     */
+    public boolean hasMoreClassNames()
+    {
+        return index < descriptor.length();
+    }
+
+
+    /**
+     * Returns the next fluff (surrounding class names) from the descriptor.
+     */
+    public String nextFluff()
+    {
+        int fluffStartIndex = index;
+
+        // Find the first token marking the start of a class name 'L' or '.'.
+        loop: while (index < descriptor.length())
+        {
+            switch (descriptor.charAt(index++))
+            {
+                case ClassConstants.INTERNAL_TYPE_GENERIC_START:
+                {
+                    nestingLevel++;
+
+                    // Make sure we have a stack.
+                    if (accumulatedClassNames == null)
+                    {
+                        accumulatedClassNames = new Stack();
+                    }
+
+                    // Remember the accumulated class name.
+                    accumulatedClassNames.push(accumulatedClassName);
+
+                    break;
+                }
+                case ClassConstants.INTERNAL_TYPE_GENERIC_END:
+                {
+                    nestingLevel--;
+
+                    // Return to the accumulated class name outside the
+                    // generic block.
+                    accumulatedClassName = (String)accumulatedClassNames.pop();
+
+                    continue loop;
+                }
+                case ClassConstants.INTERNAL_TYPE_GENERIC_BOUND:
+                {
+                    continue loop;
+                }
+                case ClassConstants.INTERNAL_TYPE_CLASS_START:
+                {
+                    // We've found the start of an ordinary class name.
+                    nestingLevel += 2;
+                    isInnerClassName = false;
+                    break loop;
+                }
+                case ClassConstants.INTERNAL_TYPE_CLASS_END:
+                {
+                    nestingLevel -= 2;
+                    break;
+                }
+                case ClassConstants.EXTERNAL_INNER_CLASS_SEPARATOR:
+                {
+                    // We've found the start of an inner class name in a signature.
+                    isInnerClassName = true;
+                    break loop;
+                }
+                case ClassConstants.INTERNAL_TYPE_GENERIC_VARIABLE_START:
+                {
+                    // We've found the start of a type identifier. Skip to the end.
+                    while (descriptor.charAt(index++) != ClassConstants.INTERNAL_TYPE_CLASS_END);
+                    break;
+                }
+            }
+
+            if (nestingLevel == 1 &&
+                descriptor.charAt(index) != ClassConstants.INTERNAL_TYPE_GENERIC_END)
+            {
+                // We're at the start of a type parameter. Skip to the start
+                // of the bounds.
+                while (descriptor.charAt(index++) != ClassConstants.INTERNAL_TYPE_GENERIC_BOUND);
+            }
+        }
+
+        return descriptor.substring(fluffStartIndex, index);
+    }
+
+
+    /**
+     * Returns the next class name from the descriptor.
+     */
+    public String nextClassName()
+    {
+        int classNameStartIndex = index;
+
+        // Find the first token marking the end of a class name '<' or ';'.
+        loop: while (true)
+        {
+            switch (descriptor.charAt(index))
+            {
+                case ClassConstants.INTERNAL_TYPE_GENERIC_START:
+                case ClassConstants.INTERNAL_TYPE_CLASS_END:
+                case ClassConstants.EXTERNAL_INNER_CLASS_SEPARATOR:
+                {
+                    break loop;
+                }
+            }
+
+            index++;
+        }
+
+        String className = descriptor.substring(classNameStartIndex, index);
+
+        // Recompose the inner class name if necessary.
+        accumulatedClassName = isInnerClassName ?
+            accumulatedClassName + ClassConstants.INTERNAL_INNER_CLASS_SEPARATOR + className :
+            className;
+
+        return accumulatedClassName;
+    }
+
+
+    /**
+     * Returns whether the most recently returned class name was a recomposed
+     * inner class name from a signature.
+     */
+    public boolean isInnerClassName()
+    {
+        return isInnerClassName;
+    }
+
+
+    /**
+     * A main method for testing the class name 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+"]");
+                DescriptorClassEnumeration enumeration = new DescriptorClassEnumeration(descriptor);
+                System.out.println("  Fluff: ["+enumeration.nextFluff()+"]");
+                while (enumeration.hasMoreClassNames())
+                {
+                    System.out.println("  Name:  ["+enumeration.nextClassName()+"]");
+                    System.out.println("  Fluff: ["+enumeration.nextFluff()+"]");
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            ex.printStackTrace();
+        }
+    }
+}

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

@@ -0,0 +1,485 @@
+/*
+ * 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.visitor.*;
+import proguard.classfile.constant.*;
+import proguard.classfile.constant.visitor.ConstantVisitor;
+import proguard.classfile.instruction.*;
+import proguard.classfile.instruction.visitor.InstructionVisitor;
+import proguard.util.StringMatcher;
+
+/**
+ * This InstructionVisitor initializes any constant <code>Class.forName</code> or
+ * <code>.class</code> references of all classes it visits. More specifically,
+ * it fills out the references of string constant pool entries that refer to a
+ * class in the program class pool or in the library class pool.
+ * <p>
+ * It optionally prints notes if on usage of
+ * <code>(SomeClass)Class.forName(variable).newInstance()</code>.
+ * <p>
+ * The class hierarchy must be initialized before using this visitor.
+ *
+ * @see ClassSuperHierarchyInitializer
+ *
+ * @author Eric Lafortune
+ */
+public class DynamicClassReferenceInitializer
+extends      SimplifiedVisitor
+implements   InstructionVisitor,
+             ConstantVisitor,
+             AttributeVisitor
+{
+    public static final int X = InstructionSequenceMatcher.X;
+    public static final int Y = InstructionSequenceMatcher.Y;
+    public static final int Z = InstructionSequenceMatcher.Z;
+
+    public static final int A = InstructionSequenceMatcher.A;
+    public static final int B = InstructionSequenceMatcher.B;
+    public static final int C = InstructionSequenceMatcher.C;
+    public static final int D = InstructionSequenceMatcher.D;
+
+
+    private final Constant[] CLASS_FOR_NAME_CONSTANTS = new Constant[]
+    {
+        // 0
+        new MethodrefConstant(1, 2, null, null),
+        new ClassConstant(3, null),
+        new NameAndTypeConstant(4, 5),
+        new Utf8Constant(ClassConstants.INTERNAL_NAME_JAVA_LANG_CLASS),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_CLASS_FOR_NAME),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_CLASS_FOR_NAME),
+
+        // 6
+        new MethodrefConstant(1, 7, null, null),
+        new NameAndTypeConstant(8, 9),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_NEW_INSTANCE),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_NEW_INSTANCE),
+
+        // 10
+        new MethodrefConstant(1, 11, null, null),
+        new NameAndTypeConstant(12, 13),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_CLASS_GET_COMPONENT_TYPE),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_CLASS_GET_COMPONENT_TYPE),
+    };
+
+    // Class.forName("SomeClass").
+    private final Instruction[] CONSTANT_CLASS_FOR_NAME_INSTRUCTIONS = new Instruction[]
+    {
+        new ConstantInstruction(InstructionConstants.OP_LDC, X),
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+    };
+
+    // (SomeClass)Class.forName(someName).newInstance().
+    private final Instruction[] CLASS_FOR_NAME_CAST_INSTRUCTIONS = new Instruction[]
+    {
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 6),
+        new ConstantInstruction(InstructionConstants.OP_CHECKCAST, X),
+    };
+
+
+//    private Constant[] DOT_CLASS_JAVAC_CONSTANTS = new Constant[]
+//    {
+//        new MethodrefConstant(A, 1, null, null),
+//        new NameAndTypeConstant(2, 3),
+//        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_DOT_CLASS_JAVAC),
+//        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_DOT_CLASS_JAVAC),
+//    };
+
+    private final Constant[] DOT_CLASS_JAVAC_CONSTANTS = new Constant[]
+    {
+        new MethodrefConstant(A, 1, null, null),
+        new NameAndTypeConstant(B, 2),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_DOT_CLASS_JAVAC),
+    };
+
+    // SomeClass.class = class$("SomeClass") (javac).
+    private final Instruction[] DOT_CLASS_JAVAC_INSTRUCTIONS = new Instruction[]
+    {
+        new ConstantInstruction(InstructionConstants.OP_LDC, X),
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+    };
+
+
+//    private Constant[] DOT_CLASS_JIKES_CONSTANTS = new Constant[]
+//    {
+//        new MethodrefConstant(A, 1, null, null),
+//        new NameAndTypeConstant(2, 3),
+//        new Utf8Constant(ClassConstants.INTERNAL_METHOD_NAME_DOT_CLASS_JIKES),
+//        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_DOT_CLASS_JIKES),
+//    };
+
+    private final Constant[] DOT_CLASS_JIKES_CONSTANTS = new Constant[]
+    {
+        new MethodrefConstant(A, 1, null, null),
+        new NameAndTypeConstant(B, 2),
+        new Utf8Constant(ClassConstants.INTERNAL_METHOD_TYPE_DOT_CLASS_JIKES),
+    };
+
+    // SomeClass.class = class("SomeClass", false) (jikes).
+    private final Instruction[] DOT_CLASS_JIKES_INSTRUCTIONS = new Instruction[]
+    {
+        new ConstantInstruction(InstructionConstants.OP_LDC, X),
+        new SimpleInstruction(InstructionConstants.OP_ICONST_0),
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+    };
+
+    // return Class.forName(v0).
+    private final Instruction[] DOT_CLASS_JAVAC_IMPLEMENTATION_INSTRUCTIONS = new Instruction[]
+    {
+        new VariableInstruction(InstructionConstants.OP_ALOAD_0),
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+        new SimpleInstruction(InstructionConstants.OP_ARETURN),
+    };
+
+    // return Class.forName(v0), if (!v1) .getComponentType().
+    private final Instruction[] DOT_CLASS_JIKES_IMPLEMENTATION_INSTRUCTIONS = new Instruction[]
+    {
+        new VariableInstruction(InstructionConstants.OP_ALOAD_0),
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+        new VariableInstruction(InstructionConstants.OP_ALOAD_1),
+        new BranchInstruction(InstructionConstants.OP_IFNE, +6),
+        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 10),
+        new SimpleInstruction(InstructionConstants.OP_ARETURN),
+    };
+
+    // return Class.forName(v0).getComponentType().
+    private final Instruction[] DOT_CLASS_JIKES_IMPLEMENTATION_INSTRUCTIONS2 = new Instruction[]
+    {
+        new VariableInstruction(InstructionConstants.OP_ALOAD_0),
+        new ConstantInstruction(InstructionConstants.OP_INVOKESTATIC, 0),
+        new ConstantInstruction(InstructionConstants.OP_INVOKEVIRTUAL, 10),
+        new SimpleInstruction(InstructionConstants.OP_ARETURN),
+    };
+
+
+    private final ClassPool      programClassPool;
+    private final ClassPool      libraryClassPool;
+    private final WarningPrinter missingNotePrinter;
+    private final WarningPrinter dependencyWarningPrinter;
+    private final WarningPrinter notePrinter;
+    private final StringMatcher  noteExceptionMatcher;
+
+
+    private final InstructionSequenceMatcher constantClassForNameMatcher =
+        new InstructionSequenceMatcher(CLASS_FOR_NAME_CONSTANTS,
+                                       CONSTANT_CLASS_FOR_NAME_INSTRUCTIONS);
+
+    private final InstructionSequenceMatcher classForNameCastMatcher =
+        new InstructionSequenceMatcher(CLASS_FOR_NAME_CONSTANTS,
+                                       CLASS_FOR_NAME_CAST_INSTRUCTIONS);
+
+    private final InstructionSequenceMatcher dotClassJavacMatcher =
+        new InstructionSequenceMatcher(DOT_CLASS_JAVAC_CONSTANTS,
+                                       DOT_CLASS_JAVAC_INSTRUCTIONS);
+
+    private final InstructionSequenceMatcher dotClassJikesMatcher =
+        new InstructionSequenceMatcher(DOT_CLASS_JIKES_CONSTANTS,
+                                       DOT_CLASS_JIKES_INSTRUCTIONS);
+
+    private final InstructionSequenceMatcher dotClassJavacImplementationMatcher =
+        new InstructionSequenceMatcher(CLASS_FOR_NAME_CONSTANTS,
+                                       DOT_CLASS_JAVAC_IMPLEMENTATION_INSTRUCTIONS);
+
+    private final InstructionSequenceMatcher dotClassJikesImplementationMatcher =
+        new InstructionSequenceMatcher(CLASS_FOR_NAME_CONSTANTS,
+                                       DOT_CLASS_JIKES_IMPLEMENTATION_INSTRUCTIONS);
+
+    private final InstructionSequenceMatcher dotClassJikesImplementationMatcher2 =
+        new InstructionSequenceMatcher(CLASS_FOR_NAME_CONSTANTS,
+                                       DOT_CLASS_JIKES_IMPLEMENTATION_INSTRUCTIONS2);
+
+
+    // A field acting as a return variable for the visitors.
+    private boolean isClassForNameInvocation;
+
+
+    /**
+     * Creates a new DynamicClassReferenceInitializer that optionally prints
+     * warnings and notes, with optional class specifications for which never
+     * to print notes.
+     */
+    public DynamicClassReferenceInitializer(ClassPool      programClassPool,
+                                            ClassPool      libraryClassPool,
+                                            WarningPrinter missingNotePrinter,
+                                            WarningPrinter dependencyWarningPrinter,
+                                            WarningPrinter notePrinter,
+                                            StringMatcher  noteExceptionMatcher)
+    {
+        this.programClassPool         = programClassPool;
+        this.libraryClassPool         = libraryClassPool;
+        this.missingNotePrinter       = missingNotePrinter;
+        this.dependencyWarningPrinter = dependencyWarningPrinter;
+        this.notePrinter              = notePrinter;
+        this.noteExceptionMatcher     = noteExceptionMatcher;
+    }
+
+
+    // Implementations for InstructionVisitor.
+
+    public void visitAnyInstruction(Clazz clazz, Method method, CodeAttribute codeAttribute, int offset, Instruction instruction)
+    {
+        // Try to match the Class.forName("SomeClass") construct.
+        instruction.accept(clazz, method, codeAttribute, offset,
+                           constantClassForNameMatcher);
+
+        // Did we find a match?
+        if (constantClassForNameMatcher.isMatching())
+        {
+            // Fill out the matched string constant.
+            clazz.constantPoolEntryAccept(constantClassForNameMatcher.matchedConstantIndex(X), this);
+
+            // Don't look for the dynamic construct.
+            classForNameCastMatcher.reset();
+        }
+
+        // Try to match the (SomeClass)Class.forName(someName).newInstance()
+        // construct.
+        instruction.accept(clazz, method, codeAttribute, offset,
+                           classForNameCastMatcher);
+
+        // Did we find a match?
+        if (classForNameCastMatcher.isMatching())
+        {
+            // Print out a note about the construct.
+            clazz.constantPoolEntryAccept(classForNameCastMatcher.matchedConstantIndex(X), this);
+        }
+
+        // Try to match the javac .class construct.
+        instruction.accept(clazz, method, codeAttribute, offset,
+                           dotClassJavacMatcher);
+
+        // Did we find a match?
+        if (dotClassJavacMatcher.isMatching() &&
+            isDotClassMethodref(clazz, dotClassJavacMatcher.matchedConstantIndex(0)))
+        {
+            // Fill out the matched string constant.
+            clazz.constantPoolEntryAccept(dotClassJavacMatcher.matchedConstantIndex(X), this);
+        }
+
+        // Try to match the jikes .class construct.
+        instruction.accept(clazz, method, codeAttribute, offset,
+                           dotClassJikesMatcher);
+
+        // Did we find a match?
+        if (dotClassJikesMatcher.isMatching() &&
+            isDotClassMethodref(clazz, dotClassJikesMatcher.matchedConstantIndex(0)))
+        {
+            // Fill out the matched string constant.
+            clazz.constantPoolEntryAccept(dotClassJikesMatcher.matchedConstantIndex(X), this);
+        }
+    }
+
+
+    // Implementations for ConstantVisitor.
+
+    /**
+     * Fills out the link to the referenced class.
+     */
+    public void visitStringConstant(Clazz clazz, StringConstant stringConstant)
+    {
+        // Save a reference to the corresponding class.
+        String externalClassName = stringConstant.getString(clazz);
+        String internalClassName = ClassUtil.internalClassName(
+                                   ClassUtil.externalBaseType(externalClassName));
+
+        stringConstant.referencedClass = findClass(clazz.getName(), internalClassName);
+    }
+
+
+    /**
+     * Prints out a note about the class cast to this class, if applicable.
+     */
+    public void visitClassConstant(Clazz clazz, ClassConstant classConstant)
+    {
+        // Print out a note about the class cast.
+        if (noteExceptionMatcher == null ||
+            !noteExceptionMatcher.matches(classConstant.getName(clazz)))
+        {
+            notePrinter.print(clazz.getName(),
+                              classConstant.getName(clazz),
+                              "Note: " +
+                              ClassUtil.externalClassName(clazz.getName()) +
+                              " calls '(" +
+                              ClassUtil.externalClassName(classConstant.getName(clazz)) +
+                              ")Class.forName(variable).newInstance()'");
+        }
+    }
+
+
+    /**
+     * Checks whether the referenced method is a .class method.
+     */
+    public void visitMethodrefConstant(Clazz clazz, MethodrefConstant methodrefConstant)
+    {
+        String methodType = methodrefConstant.getType(clazz);
+
+        // Do the method's class and type match?
+        if (methodType.equals(ClassConstants.INTERNAL_METHOD_TYPE_DOT_CLASS_JAVAC) ||
+            methodType.equals(ClassConstants.INTERNAL_METHOD_TYPE_DOT_CLASS_JIKES))
+        {
+            String methodName = methodrefConstant.getName(clazz);
+
+            // Does the method's name match one of the special names?
+            isClassForNameInvocation =
+                methodName.equals(ClassConstants.INTERNAL_METHOD_NAME_DOT_CLASS_JAVAC) ||
+                methodName.equals(ClassConstants.INTERNAL_METHOD_NAME_DOT_CLASS_JIKES);
+
+            if (isClassForNameInvocation)
+            {
+                return;
+            }
+
+            String className = methodrefConstant.getClassName(clazz);
+
+            // Note that we look for the class by name, since the referenced
+            // class has not been initialized yet.
+            Clazz referencedClass = programClassPool.getClass(className);
+            if (referencedClass != null)
+            {
+                // Check if the code of the referenced method is .class code.
+                // Note that we look for the method by name and type, since the
+                // referenced method has not been initialized yet.
+                referencedClass.methodAccept(methodName,
+                                             methodType,
+                                             new AllAttributeVisitor(this));
+            }
+        }
+    }
+
+
+    // Implementations for AttributeVisitor.
+
+    public void visitAnyAttribute(Clazz clazz, Attribute attribute) {}
+
+
+    public void visitCodeAttribute(Clazz clazz, Method method, CodeAttribute codeAttribute)
+    {
+        // Check whether this is class$(String), as generated by javac, or
+        // class(String, boolean), as generated by jikes, or an optimized
+        // version.
+        isClassForNameInvocation =
+            isDotClassMethodCode(clazz, method, codeAttribute,
+                                 dotClassJavacImplementationMatcher, 5)  ||
+            isDotClassMethodCode(clazz, method, codeAttribute,
+                                 dotClassJikesImplementationMatcher, 12) ||
+            isDotClassMethodCode(clazz, method, codeAttribute,
+                                 dotClassJikesImplementationMatcher2, 8);
+    }
+
+
+    // Small utility methods.
+
+    /**
+     * Returns whether the given method reference corresponds to a .class
+     * method, as generated by javac or by jikes.
+     */
+    private boolean isDotClassMethodref(Clazz clazz, int methodrefConstantIndex)
+    {
+        isClassForNameInvocation = false;
+
+        // Check if the code of the referenced method is .class code.
+        clazz.constantPoolEntryAccept(methodrefConstantIndex, this);
+
+        return isClassForNameInvocation;
+    }
+
+
+    /**
+     * Returns whether the first whether the first instructions of the
+     * given code attribute match with the given instruction matcher.
+     */
+    private boolean isDotClassMethodCode(Clazz                      clazz,
+                                         Method                     method,
+                                         CodeAttribute              codeAttribute,
+                                         InstructionSequenceMatcher codeMatcher,
+                                         int                        codeLength)
+    {
+        // Check the minimum code length.
+        if (codeAttribute.u4codeLength < codeLength)
+        {
+            return false;
+        }
+
+        // Check the actual instructions.
+        codeMatcher.reset();
+        codeAttribute.instructionsAccept(clazz, method, 0, codeLength, codeMatcher);
+        return codeMatcher.isMatching();
+    }
+
+
+    /**
+     * 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 &&
+                missingNotePrinter != null)
+            {
+                // We didn't find the superclass or interface. Print a note.
+                missingNotePrinter.print(referencingClassName,
+                                         name,
+                                         "Note: " +
+                                         ClassUtil.externalClassName(referencingClassName) +
+                                         ": can't find dynamically 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 dynamically on program class " +
+                                           ClassUtil.externalClassName(name));
+        }
+
+        return clazz;
+    }
+}