/* Copyright (c) 2002-2008 Sun Microsystems, Inc. All rights reserved
 *
 * This program is distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */
package org.pantsbuild.jmake;

import java.io.Serializable;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * A reflection of a class, in the form that allows fast checks and information obtaining.
 *
 * @author Misha Dmitriev
 *  5 April 2004
 */
@SuppressWarnings("serial")
public class ClassInfo implements Serializable {

    public static final int VER_OLD = 0;  // Old version
    public static final int VER_NEW = 1;  // New version
    public static final int NO_VERSIONS = 2;  // Non-project class, no change tracking
    private transient PCDManager pcdm;
    transient int verCode;                          // Version code for this ClassInfo - one of the above.
    String name = null;
    transient String packageName;                   // Package name; restored when database is reloaded
    int javacTargetRelease = Utils.JAVAC_TARGET_RELEASE_OLDEST; // Can have values from Utils.JAVAC_TARGET_RELEASE_xxx
    String cpoolRefsToClasses[];          // Directly referenced class names trimmed of array and 'L' prefixes and ';' suffixes
    boolean isRefClassArray[];            // Indicates if a directly referenced class is actually an array class
    // In all signatures we replace the 'L' and ';' symbols that enclose non-primitive type names with '@' and '#' respectively,
    // so that class names inside signatures can be located fast and unambiguously.
    String cpoolRefsToFieldClasses[];     // Defining classes of referenced fields, trimmed of enclosing 'L' and ';' symbols
    String cpoolRefsToFieldNames[];       // Names of referenced fields
    String cpoolRefsToFieldSignatures[];  // Signatures of referenced fields
    String cpoolRefsToMethodClasses[];    // Defining classes of referenced methods, trimmed of enclosing 'L' and ';' symbols
    String cpoolRefsToMethodNames[];      // Names of referenced methods
    String cpoolRefsToMethodSignatures[]; // Signatures of referenced methods
    char accessFlags;                     // isInterface flag included
    boolean isNonMemberNestedClass = false; // True if this is a non-member nested class
    String superName;
    String interfaces[];
    String fieldNames[];
    String fieldSignatures[];
    char fieldAccessFlags[];
    Object primitiveConstantInitValues[];
    String methodNames[];
    String methodSignatures[];
    char methodAccessFlags[];
    String checkedExceptions[][];
    transient ClassInfo directSubclasses[];       // Direct subclasses. Created lazily and not preserved on disk.
    transient String directlyEnclosingClass;      // Directly enclosing class name; restored when database is reloaded
    transient String topLevelEnclosingClass;      // Top-level enclosing class name; restored when database is reloaded
    String nestedClasses[];             // Names of all nested classes. Don't make transient - it's used to check
    // if nested classes for this class were added/deleted in new version
    transient char nestedClassAccessFlags[];      // No need to store this information permanently
    transient boolean nestedClassNonMember[];     // Ditto

    /** Creates new ClassInfo out of a class file. The last parameter is needed only to produce sensible error reports.*/
    public ClassInfo(byte[] classFileBytes, int verCode, PCDManager pcdm, String classFileFullPath) {
        this.pcdm = pcdm;
        this.verCode = verCode;
        pcdm.getClassFileReader().readClassFile(classFileBytes, this, classFileFullPath, true);
        packageName = Utils.getPackageName(name);
        directlyEnclosingClass =
                Utils.getDirectlyEnclosingClass(name, this.javacTargetRelease);
        topLevelEnclosingClass = Utils.getTopLevelEnclosingClass(name);
    }

    /**
     * Create a "lightweight" ClassInfo, that contains just the class name, super name, interfaces, flags and verCode.
     * Used for non-project classes, that don't change themselves, for which we are only interested in type hierarchy structure.
     */
    public ClassInfo(byte[] classFileBytes, PCDManager pcdm, String classFileFullPath) {
        this.pcdm = pcdm;
        this.verCode = NO_VERSIONS;
        pcdm.getClassFileReader().readClassFile(classFileBytes, this, classFileFullPath, false);
        packageName = Utils.getPackageName(name);
        directlyEnclosingClass =
                Utils.getDirectlyEnclosingClass(name, this.javacTargetRelease);
        topLevelEnclosingClass = Utils.getTopLevelEnclosingClass(name);
    }

    /** Even more lightweight variant - created for a deleted non-project class, to enable minimum possible checks. */
    public ClassInfo(String name, PCDManager pcdm) {
        this.pcdm = pcdm;
        this.verCode = NO_VERSIONS;
        this.name = name;
        packageName = Utils.getPackageName(name);
        directlyEnclosingClass = Utils.getDirectlyEnclosingClass(name, 0);
        topLevelEnclosingClass = Utils.getTopLevelEnclosingClass(name);
    }

    public ClassInfo() {
    }

    /** Initialize transient data that can be initialized immediately after this ClassInfo is read from the project database */
    public void initializeImmediateTransientFields() {
        verCode = VER_OLD;

        packageName = Utils.getPackageName(name);

        directlyEnclosingClass =
                Utils.getDirectlyEnclosingClass(name, this.javacTargetRelease);
        topLevelEnclosingClass = Utils.getTopLevelEnclosingClass(name);
    }

    /**
     * Called to restore the pointer to the current PCDManager after this ClassInfo is brought back
     * from the store.
     */
    public void restorePCDM(PCDManager pcdm) {
        this.pcdm = pcdm;
    }

    public boolean isInterface() {
        return Modifier.isInterface(accessFlags);
    }

    public boolean isAbstract() {
        return Modifier.isAbstract(accessFlags);
    }

    public boolean isPublic() {
        return Modifier.isPublic(accessFlags);
    }

    /**
     * Returns the names of the superclasses of the given class (transitively), that belong
     * to the same project, plus those of the superclasses that can be found on the class path
     * supplied to jmake, and on the boot class path.
     */
    public List<String> getAllSuperclassNames() {
        List<String> res = new ArrayList<String>();
        String superName = this.superName;
        while (superName != null && !"java/lang/Object".equals(superName)) {
            res.add(superName);
            ClassInfo classInfo = pcdm.getClassInfoForName(verCode, superName);
            if (classInfo == null) { // Class not in project (or deleted?). Try to find it and further superclasses in non-project classes
                ClassPath.getSuperclasses(superName, res, pcdm);
                break;
            }
            superName = classInfo.superName;
        }
        return res;
    }

    /**
     * Returns the set of names of the interfaces transitively implemented by the given
     * class, that belong to the same project.
     */
    public Set<String> getAllImplementedIntfNames() {
        Set<String> res = new LinkedHashSet<String>();
        addImplementedInterfaceNames(false, res);
        return res;
    }

    /** Add to the given set the names of direct/all interfaces implemented by the given class. */
    private void addImplementedInterfaceNames(boolean directOnly,
            Set<String> intfSet) {
        if (interfaces != null) {
            for (int i = 0; i < interfaces.length; i++) {
                String superIntfName = interfaces[i];
                intfSet.add(superIntfName);
                if (directOnly) {
                    continue;
                }
                ClassInfo superIntfInfo =
                        pcdm.getClassInfoForName(verCode, superIntfName);
                if (superIntfInfo == null) {  // Class not in project
                    ClassPath.addAllImplementedInterfaceNames(superIntfName, intfSet, pcdm);
                } else {
                    superIntfInfo.addImplementedInterfaceNames(false, intfSet);
                }
            }
        }

        if (directOnly || superName == null ||
                "java/lang/Object".equals(superName)) {
            return;
        }
        ClassInfo superInfo = pcdm.getClassInfoForName(verCode, superName);
        if (superInfo == null) {  // Class not in project
            ClassPath.addAllImplementedInterfaceNames(superName, intfSet, pcdm);
        } else {
            superInfo.addImplementedInterfaceNames(false, intfSet);
        }
    }

    /** Returns the array of all direct subclasses of this class (array of zero length if there are none). */
    public ClassInfo[] getDirectSubclasses() {
        if (directSubclasses != null) {
            return directSubclasses;
        }

        List<ClassInfo> listRes = new ArrayList<ClassInfo>();

        for (PCDEntry entry : pcdm.entries()) {
            ClassInfo classInfo = pcdm.getClassInfoForPCDEntry(verCode, entry);
            if (classInfo == null) {
                continue;  // New or deleted class, depending on verCode
            }
            if (classInfo.superName.equals(name)) {
                listRes.add(classInfo);
            }
        }

        directSubclasses = listRes.toArray(new ClassInfo[listRes.size()]);
        return directSubclasses;
    }

    /** Check if the initial values for the given primitive constatnts in two classes are the same. */
    public static boolean constFieldInitValuesEqual(ClassInfo oldClassInfo, int oldFieldNo,
            ClassInfo newClassInfo, int newFieldNo) {
        Object oldInitValue = oldClassInfo.primitiveConstantInitValues == null ? null
                : oldClassInfo.primitiveConstantInitValues[oldFieldNo];
        Object newInitValue = newClassInfo.primitiveConstantInitValues == null ? null
                : newClassInfo.primitiveConstantInitValues[newFieldNo];
        if (oldInitValue == newInitValue) {
            return true;
        }
        if (oldInitValue == null || newInitValue == null) {
            return false;
        }

        if (oldInitValue instanceof Integer) {
            if (((Integer) oldInitValue).intValue() == ((Integer) newInitValue).intValue()) {
                return true;
            } else {
                return false;
            }
        } else if (oldInitValue instanceof String) {
            if ( ((String) oldInitValue).equals((String) newInitValue) ) {
                return true;
            } else {
                return false;
            }
        } else if (oldInitValue instanceof Long) {
            if (((Long) oldInitValue).longValue() == ((Long) newInitValue).longValue()) {
                return true;
            } else {
                return false;
            }
        } else if (oldInitValue instanceof Float) {
            if (((Float) oldInitValue).floatValue() == ((Float) newInitValue).floatValue()) {
                return true;
            } else {
                return false;
            }
        } else if (oldInitValue instanceof Double) {
            if (((Double) oldInitValue).doubleValue() == ((Double) newInitValue).doubleValue()) {
                return true;
            } else {
                return false;
            }
        }

        return true;
    }

    public boolean implementsInterfaceDirectly(String intfName) {
        if (interfaces == null) {
            return false;
        }
        for (int i = 0; i < interfaces.length; i++) {
            if (intfName.equals(interfaces[i])) {
                return true;
            }
        }
        return false;
    }

    /** Check if this class implements interface I or any subinterface of I directly */
    public boolean implementsIntfOrSubintfDirectly(String intfName) {
        if (interfaces == null) {
            return false;
        }
        for (int i = 0; i < interfaces.length; i++) {
            if (intfName.equals(interfaces[i])) {
                return true;
            }
            // An interface can have multiple superinterfaces, all of which are listed in its "interfaces" array
            // (although in the .java source it "extends" them all).
            ClassInfo superIntfInfo =
                    pcdm.getClassInfoForName(verCode, interfaces[i]);
            if (superIntfInfo == null) {
                continue;  // Class not in project
            }
            if (superIntfInfo.implementsIntfOrSubintfDirectly(intfName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Class C implements interface I indirectly, if C or some superclass of C directly implements I
     * or some subinterface of I.
     */
    public boolean implementsInterfaceDirectlyOrIndirectly(String intfName) {
        if (interfaces == null) {
            return false;
        }

        if (implementsIntfOrSubintfDirectly(intfName)) {
            return true;
        }

        if (superName != null) {
            ClassInfo superInfo = pcdm.getClassInfoForName(verCode, superName);
            if (superInfo == null) {
                return false;  // Class not in project
            }
            return superInfo.implementsInterfaceDirectlyOrIndirectly(intfName);
        }

        return false;
    }

    /**
     * Returns true if this class declares a field with the same name and type as
     * the field number fieldNo in class classInfo.
     */
    public boolean declaresField(ClassInfo classInfo, int fieldNo) {
        if (fieldNames == null) {
            return false;
        }
        String fieldName = classInfo.fieldNames[fieldNo];
        String fieldSignature = classInfo.fieldSignatures[fieldNo];

        for (int i = 0; i < fieldNames.length; i++) {
            if (fieldName.equals(fieldNames[i]) &&
                    fieldSignature.equals(fieldSignatures[i])) {
                return true;
            }
        }
        return false;
    }

    /** Returns true if this class declares a field with the given name, signature and access */
    public boolean declaresField(String name, String signature, boolean isStatic) {
        if (fieldNames == null) {
            return false;
        }
        signature = ("@" + signature + "#").intern();
        for (int i = 0; i < fieldNames.length; i++) {
            if (name.equals(fieldNames[i]) &&
                    signature.equals(fieldSignatures[i]) &&
                    Modifier.isStatic(fieldAccessFlags[i]) == isStatic) {
                return true;
            }
        }
        return false;
    }

    /**
     * Returns true if this class declares a method with the same name and signature as
     * the method number methodNo in class classInfo.
     */
    public boolean declaresMethod(ClassInfo classInfo, int methodNo) {
        if (methodNames == null) {
            return false;
        }
        String methodName = classInfo.methodNames[methodNo];
        String methodSignature = classInfo.methodSignatures[methodNo];

        for (int i = 0; i < methodNames.length; i++) {
            if (methodName.equals(methodNames[i]) &&
                    methodSignature.equals(methodSignatures[i])) {
                return true;
            }
        }
        return false;
    }

    /**
     * If this class declares a method with the same name and signature as the given method,
     * return its position. Otherwise, return -1.
     */
    public int getDeclaredMethodPos(ClassInfo classInfo, int methodNo) {
        if (methodNames == null) {
            return -1;
        }
        String methodName = classInfo.methodNames[methodNo];
        String methodSignature = classInfo.methodSignatures[methodNo];

        for (int i = 0; i < methodNames.length; i++) {
            if (methodName.equals(methodNames[i]) &&
                    methodSignature.equals(methodSignatures[i])) {
                return i;
            }
        }
        return -1;
    }

    /**
     * Returns a nonnegative number (position in the method array) if this class declares a method with the
     * name methodName, and -1 otherwise.
     */
    public int declaresSameNameMethod(String methodName) {
        if (methodNames == null) {
            return -1;
        }
        for (int j = 0; j < methodNames.length; j++) {
            if (methodName.equals(methodNames[j])) {
                return j;
            }
        }
        return -1;
    }

    /**
     * Check if this class references the given class in different ways, depending on thorDegree parameter.
     * thorDegree = 0: the given class (but not its array class) directly from the constantpool.
     *
     * thorDegree = 1: the given class or its array class directly from the constantpool, as a
     * type of a data field, as a type in a method signature or a thrown exception, as a directly
     * implemented interface or a direct superclass
     *
     * thorDegree = 2: the given class or its array class directly or indirectly from the
     * constantpool, as a type of a data field, as a type in a method signature or a thrown exception,
     * as a directly/indirectly implemented interface or a direct/indirect superclass.
     *
     * isRefTypeInterface indicates whether className is an interface.
     */
    public boolean referencesClass(String className, boolean isRefTypeInterface, int thorDegree) {
        int i;

        if (thorDegree == 0) {
            if (cpoolRefsToClasses == null) {
                return false;
            }
            for (i = 0; i < cpoolRefsToClasses.length; i++) {
                if (!isRefClassArray[i] &&
                        className.equals(cpoolRefsToClasses[i])) {
                    return true;
                }
            }
        } else {
            if (isSubclassOf(className, (thorDegree == 1))) {
                return true;
            }
            if (isRefTypeInterface) {
                if (thorDegree == 1) {
                    if (implementsInterfaceDirectly(className)) {
                        return true;
                    }
                } else {
                    // Check for indirectly implemented interfaces
                    if (implementsInterfaceDirectlyOrIndirectly(className)) {
                        return true;
                    }
                }
            }

            if (cpoolRefsToClasses != null) {
                for (i = 0; i < cpoolRefsToClasses.length; i++) {
                    if (className.equals(cpoolRefsToClasses[i])) {
                        return true;
                    }
                }
            }
            if (thorDegree == 2) {
                // Check for indirect references from the constantpool
                if (cpoolRefsToFieldSignatures != null) {
                    for (i = 0; i < cpoolRefsToFieldSignatures.length; i++) {
                        if (signatureIncludesClassName(cpoolRefsToFieldSignatures[i], className)) {
                            return true;
                        }
                    }
                }
                if (cpoolRefsToMethodNames != null) {
                    for (i = 0; i < cpoolRefsToMethodSignatures.length; i++) {
                        if (signatureIncludesClassName(cpoolRefsToMethodSignatures[i], className)) {
                            return true;
                        }
                    }
                }
            }

            if (fieldSignatures != null) {
                for (i = 0; i < fieldSignatures.length; i++) {
                    if (signatureIncludesClassName(fieldSignatures[i], className)) {
                        return true;
                    }
                }
            }
            if (methodSignatures != null) {
                for (i = 0; i < methodSignatures.length; i++) {
                    if (signatureIncludesClassName(methodSignatures[i], className)) {
                        return true;
                    }
                }
            }
            if (checkedExceptions != null) {
                for (i = 0; i < checkedExceptions.length; i++) {
                    if (checkedExceptions[i] != null) {
                        String excArray[] = checkedExceptions[i];
                        for (int j = 0; j < excArray.length; j++) {
                            if (className.equals(excArray[j])) {
                                return true;
                            }
                        }
                    }
                }
            }
        }

        return false;
    }

    private static boolean signatureIncludesClassName(String signature, String className) {
        int stIndex = signature.indexOf(className);
        if (stIndex == -1) {
            return false;
        }
        return ((stIndex != 0 && signature.charAt(stIndex - 1) == '@' && signature.charAt(stIndex + className.length()) == '#') ||
                (stIndex == 0 && signature.length() == className.length()));
    }

    public boolean isSubclassOf(String className, boolean directOnly) {
        if (className.equals(superName)) {
            return true;
        }
        if (directOnly) {
            return false;
        }
        String superName = this.superName;
        while (superName != null) {
            if (className.equals(superName)) {
                return true;
            }
            ClassInfo classInfo = pcdm.getClassInfoForName(verCode, superName);
            if (classInfo == null) {
                break;  // Class not in project
            }
            superName = classInfo.superName;
        }
        return false;
    }

    /**
     * Check if this class references field number fieldNo of class fieldDefClassInfo. Let us call
     * this field C.f. Actual reference contained in the constant pool may be not to C.f itself,
     * but to Csub.f, where Csub is some subclass of C such that neither Csub nor any other class
     * located between C and Csub in the class hierarchy redeclares f. We look up both "real"
     * references C.f and "fake" references such as Csub.f.
     */
    public boolean referencesField(ClassInfo fieldDefClassInfo, int fieldNo) {
        if (cpoolRefsToFieldNames == null) {
            return false;
        }
        String fieldDefClassName = fieldDefClassInfo.name;
        String fieldName = fieldDefClassInfo.fieldNames[fieldNo];
        String fieldSig = fieldDefClassInfo.fieldSignatures[fieldNo];
        for (int i = 0; i < cpoolRefsToFieldNames.length; i++) {
            if (fieldName.equals(cpoolRefsToFieldNames[i]) &&
                    fieldSig.equals(cpoolRefsToFieldSignatures[i]) ) {
                if (fieldDefClassName.equals(cpoolRefsToFieldClasses[i]) ) {
                    return true;  // "real" reference
                } else {  // Check if this is a "fake" reference that resolves to the above "real" reference
                    ClassInfo classInThisCpool =
                            pcdm.getClassInfoForName(verCode, cpoolRefsToFieldClasses[i]);
                    if (classInThisCpool == null) {
                        continue;  // Class not in project
                    }
                    if (!classInThisCpool.isSubclassOf(fieldDefClassInfo.name, false)) {
                        continue;
                    }

                    // Ok, now check that this field is not actually redeclared in fieldDefClassInfo or
                    // somewhere in between it and classInThisCpool
                    boolean redeclared = false;
                    ClassInfo curClass = classInThisCpool;
                    do {
                        if (curClass.declaresField(fieldDefClassInfo, fieldNo)) {
                            redeclared = true;
                            break;
                        }
                        String superName = curClass.superName;
                        curClass = pcdm.getClassInfoForName(verCode, superName);
                        if (curClass == null) {
                            break;
                        }
                    } while (curClass != fieldDefClassInfo);
                    if (!redeclared) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * Check if this class references method number methodNo of class methodDefClassInfo. Let us
     * call this method C.m. Actual reference contained in the constant pool may be not to C.m
     * itself, but to Csub.m, where Csub is some subclass of C such that neither Csub nor any
     * other class located between C and Csub in the class hierarchy redeclares m. We look up
     * both "real" references C.m and "fake" references such as Csub.m.
     */
    public boolean referencesMethod(ClassInfo methodDefClassInfo, int methodNo) {
        if (cpoolRefsToMethodNames == null) {
            return false;
        }
        String methodDefClassName = methodDefClassInfo.name;
        String methodName = methodDefClassInfo.methodNames[methodNo];
        String methodSig = methodDefClassInfo.methodSignatures[methodNo];
        for (int i = 0; i < cpoolRefsToMethodNames.length; i++) {
            if (methodName.equals(cpoolRefsToMethodNames[i]) &&
                    methodSig.equals(cpoolRefsToMethodSignatures[i])) {
                if (methodDefClassName.equals(cpoolRefsToMethodClasses[i])) {
                    return true;  // "real" reference
                } else {  // Check if this is a "fake" reference that resolves to the above "real" reference
                    // Be careful - class in the cpool may be not a project class (e.g. a core class).
                    ClassInfo classInThisCpool =
                            pcdm.getClassInfoForName(verCode, cpoolRefsToMethodClasses[i]);
                    if (classInThisCpool == null) {
                        continue;  // Class not in project
                    }
                    if (classInThisCpool.isSubclassOf(methodDefClassInfo.name, false)) {
                        // Ok, now check that this method is not actually redeclared in classInThisCpool (which is
                        // lower in the hierarchy) or somewhere in between it and classInThisCpool
                        boolean redeclared = false;
                        ClassInfo curClass = classInThisCpool;
                        do {
                            if (curClass.declaresMethod(methodDefClassInfo, methodNo)) {
                                redeclared = true;
                                break;
                            }
                            String superName = curClass.superName;
                            curClass =
                                    pcdm.getClassInfoForName(verCode, superName);
                            if (curClass == null) {
                                break;
                            }
                        } while (curClass != methodDefClassInfo);
                        if (!redeclared) {
                            return true;
                        }
                    } else if (methodDefClassInfo.isInterface() && classInThisCpool.implementsIntfOrSubintfDirectly(methodDefClassName)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * If this class has a method that throws the given exception, return its index. Otherwise return -1.
     * The search starts from method with index startMethodIdx.
     */
    public int hasMethodThrowingException(ClassInfo excClassInfo, int startMethodIdx) {
        if (checkedExceptions == null) {
            return -1;
        }
        if (startMethodIdx >= checkedExceptions.length) {
            return -1;
        }
        String excName = excClassInfo.name;
        for (int i = startMethodIdx; i < checkedExceptions.length; i++) {
            if (checkedExceptions[i] == null) {
                continue;
            }
            String[] exc = checkedExceptions[i];
            for (int j = 0; j < exc.length; j++) {
                if (exc[j].equals(excName)) {
                    return i;
                }
            }
        }
        return -1;
    }

    public static abstract class MethodHandler {

        abstract void handleMethod(ClassInfo ci, int methodIdx);
    }

    /**
     * Check this class and all its superclasses (if includeSuperclasses == true) and superinterfaces (if includeInterfaces == true)
     * for a method with the given name. If such a method is found, call h.handleMethod(classInfo, methodIdx).
     */
    public void findExistingSameNameMethods(String methodName, boolean includeSuperclasses, boolean includeInterfaces, MethodHandler h) {
        String className = name;
        ClassInfo classInfo;
        while (className != null) {
            classInfo = pcdm.getClassInfoForName(verCode, className);
            if (classInfo == null) {
                break;  // Class not in project
            }
            String mNames[] = classInfo.methodNames;
            int mNamesLen = mNames != null ? mNames.length : 0;
            for (int i = 0; i < mNamesLen; i++) {
                if (methodName.equals(mNames[i])) {
                    h.handleMethod(classInfo, i);
                }
            }
            if (includeInterfaces && classInfo.interfaces != null) {
                String intfNames[] = classInfo.interfaces;
                for (int i = 0; i < intfNames.length; i++) {
                    ClassInfo superIntfInfo =
                            pcdm.getClassInfoForName(verCode, intfNames[i]);
                    if (superIntfInfo == null) {
                        continue;  // Class not in project
                    }
                    superIntfInfo.findExistingSameNameMethods(methodName, true, includeInterfaces, h);
                }
            }
            if (includeSuperclasses) {
                className = classInfo.superName;
            } else {
                return;
            }
        }
    }

    public static boolean isPrimitiveFieldSig(String fieldSig) {
        return fieldSig.indexOf('@') == -1;
    }

    /**
     * Check if the given signature is of a class type, and that class does not belong to the project.
     * It used to be a check for just a core type name, but sometimes people use JDK sources as e.g. a test
     * case - so better perform a universal (and entirely correct, unlike just a core type name) test here.
     */
    public boolean isNonProjectClassTypeFieldSig(String fieldSig) {
        int stPos = fieldSig.indexOf('@');
        if (stPos == -1) {
            return false;
        }
        int endPos = fieldSig.indexOf('#');
        String className = fieldSig.substring(stPos + 1, endPos);
        return (!pcdm.isProjectClass(verCode, className));
    }

    /** For debugging. */
    public String toString() {
        return name + (verCode == VER_OLD ? " OLD" : " NEW");
    }
}