private boolean checkParameters(
     char[] methodDescriptor,
     char[][] parameterSimpleNames,
     char[][] parameterQualifications,
     boolean isCaseSensitive,
     boolean isCamelCase) {
   char[][] arguments = Signature.getParameterTypes(methodDescriptor);
   int parameterCount = parameterSimpleNames.length;
   if (parameterCount != arguments.length) return false;
   for (int i = 0; i < parameterCount; i++)
     if (!checkTypeName(
         parameterSimpleNames[i],
         parameterQualifications[i],
         Signature.toCharArray(arguments[i]),
         isCaseSensitive,
         isCamelCase)) return false;
   return true;
 }
  boolean matchField(FieldPattern pattern, Object binaryInfo, IBinaryType enclosingBinaryType) {
    if (!pattern.findDeclarations) return false; // only relevant when finding declarations
    if (!(binaryInfo instanceof IBinaryField)) return false;

    IBinaryField field = (IBinaryField) binaryInfo;
    if (!pattern.matchesName(pattern.name, field.getName())) return false;
    if (!checkDeclaringType(
        enclosingBinaryType,
        pattern.declaringSimpleName,
        pattern.declaringQualification,
        pattern.isCaseSensitive(),
        pattern.isCamelCase())) return false;

    char[] fieldTypeSignature = Signature.toCharArray(convertClassFileFormat(field.getTypeName()));
    return checkTypeName(
        pattern.typeSimpleName,
        pattern.typeQualification,
        fieldTypeSignature,
        pattern.isCaseSensitive(),
        pattern.isCamelCase());
  }
  boolean matchMethod(MethodPattern pattern, Object binaryInfo, IBinaryType enclosingBinaryType) {
    if (!pattern.findDeclarations) return false; // only relevant when finding declarations
    if (!(binaryInfo instanceof IBinaryMethod)) return false;

    IBinaryMethod method = (IBinaryMethod) binaryInfo;
    if (!pattern.matchesName(pattern.selector, method.getSelector())) return false;
    if (!checkDeclaringType(
        enclosingBinaryType,
        pattern.declaringSimpleName,
        pattern.declaringQualification,
        pattern.isCaseSensitive(),
        pattern.isCamelCase())) return false;

    // look at return type only if declaring type is not specified
    boolean checkReturnType =
        pattern.declaringSimpleName == null
            && (pattern.returnSimpleName != null || pattern.returnQualification != null);
    boolean checkParameters = pattern.parameterSimpleNames != null;
    if (checkReturnType || checkParameters) {
      char[] methodDescriptor = convertClassFileFormat(method.getMethodDescriptor());
      if (checkReturnType) {
        char[] returnTypeSignature =
            Signature.toCharArray(Signature.getReturnType(methodDescriptor));
        if (!checkTypeName(
            pattern.returnSimpleName,
            pattern.returnQualification,
            returnTypeSignature,
            pattern.isCaseSensitive(),
            pattern.isCamelCase())) return false;
      }
      if (checkParameters
          && !checkParameters(
              methodDescriptor,
              pattern.parameterSimpleNames,
              pattern.parameterQualifications,
              pattern.isCaseSensitive(),
              pattern.isCamelCase())) return false;
    }
    return true;
  }
 private boolean checkAnnotation(IBinaryAnnotation annotation, TypeReferencePattern pattern) {
   if (checkTypeName(
       pattern.simpleName,
       pattern.qualification,
       convertClassFileFormat(Signature.toCharArray(annotation.getTypeName())),
       pattern.isCaseSensitive,
       pattern.isCamelCase)) {
     return true;
   }
   IBinaryElementValuePair[] valuePairs = annotation.getElementValuePairs();
   if (valuePairs != null) {
     for (int j = 0, vpLength = valuePairs.length; j < vpLength; j++) {
       IBinaryElementValuePair valuePair = valuePairs[j];
       Object pairValue = valuePair.getValue();
       if (pairValue instanceof IBinaryAnnotation) {
         if (checkAnnotation((IBinaryAnnotation) pairValue, pattern)) {
           return true;
         }
       }
     }
   }
   return false;
 }