import org.apache.bcel.classfile.Field; //导入依赖的package包/类
Field findField(String className, String fieldName) {
	try {
		// System.out.println("Looking for " + className);
		JavaClass fieldDefinedIn = getThisClass();
		if (!className.equals(getClassName())) {
			// System.out.println("Using repository to look for " + className);

			fieldDefinedIn = Repository.lookupClass(className);
		}
		Field[] f = fieldDefinedIn.getFields();
		for (int i = 0; i < f.length; i++)
			if (f[i].getName().equals(fieldName)) {
				// System.out.println("Found " + f[i]);
				return f[i];
			}
		return null;
	} catch (ClassNotFoundException e) {
		return null;
	}
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
public void visit(Field obj) {
if (getFieldName().length() == 1) return;

if (!obj.isFinal() 
	&& Character.isLetter(getFieldName().charAt(0))
	&& !Character.isLowerCase(getFieldName().charAt(0))
	&& getFieldName().indexOf("_") == -1
	&& Character.isLetter(getFieldName().charAt(1))
	&& Character.isLowerCase(getFieldName().charAt(1)))
	bugReporter.reportBug(new BugInstance(this, 
		"NM_FIELD_NAMING_CONVENTION", 
		classIsPublicOrProtected 
		 && (obj.isPublic() || obj.isProtected())  
		? NORMAL_PRIORITY
		: LOW_PRIORITY)
	        .addClass(this)
	        .addVisitedField(this)
		);
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
public void visit(Field obj) {
	super.visit(obj);
	int flags = obj.getAccessFlags();
	boolean isStatic = (flags & ACC_STATIC) != 0;
	if (!isStatic) return;
	boolean isFinal = (flags & ACC_FINAL) != 0;
	boolean isPublic = publicClass && (flags & ACC_PUBLIC) != 0;
	boolean isProtected = publicClass && (flags & ACC_PROTECTED) != 0;
	if (!isPublic && !isProtected) return;

	boolean isHashtable = 
		getFieldSig().equals("Ljava/util/Hashtable;");
	boolean isArray = getFieldSig().charAt(0) == '[';

	if (isFinal && !(isHashtable || isArray)) return;

	FieldRecord f = new FieldRecord();
	f.className = getDottedClassName();
	f.name = getFieldName();
	f.signature = getDottedFieldSig();
	f.isPublic = isPublic;
	f.isFinal = isFinal;

	seen.add(f);

}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/**
 * Find a field with given name defined in given class.
 *
 * @param className the name of the class
 * @param fieldName the name of the field
 * @return the Field, or null if no such field could be found
 */
public static Field findField(String className, String fieldName) throws ClassNotFoundException {
	JavaClass jclass = Repository.lookupClass(className);

	while (jclass != null) {
		Field[] fieldList = jclass.getFields();
		for (int i = 0; i < fieldList.length; ++i) {
			Field field = fieldList[i];
			if (field.getName().equals(fieldName)) {
				return field;
			}
		}

		jclass = jclass.getSuperClass();
	}

	return null;
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/** @see com.puppycrawl.tools.checkstyle.bcel.IObjectSetVisitor */
public void leaveSet(Set aJavaClasses)
{
    final Iterator it = aJavaClasses.iterator();
    while (it.hasNext()) {
        final JavaClass javaClass = (JavaClass) it.next();
        final String className = javaClass.getClassName();
        final JavaClassDefinition classDef = findJavaClassDef(javaClass);
        final FieldDefinition[] fieldDefs = classDef.getFieldDefs();
        for (int i = 0; i < fieldDefs.length; i++) {
            if (fieldDefs[i].getReadReferenceCount() == 0) {
                final Field field = fieldDefs[i].getField();
                if (!field.isFinal()
                    && (!ignore(className, field))
                    )
                {
                    log(
                        javaClass,
                        0,
                        "unread.field",
                        new Object[] {fieldDefs[i]});
                }
            }
        }
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
@Override
public void visitClassContext(ClassContext classContext) {
    JavaClass javaClass = classContext.getJavaClass();
    if (OBJECT_MAPPER_CLASSES.contains(javaClass.getClassName())) {
        return;
    }
    for (Field field : javaClass.getFields()) {
        analyzeField(field, javaClass);
    }
    for (Method m : javaClass.getMethods()) {
        try {
            analyzeMethod(m, classContext);
        }
        catch (CFGBuilderException | DataflowAnalysisException e) {
        }
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
private void analyzeField(Field field, JavaClass javaClass) {
    for (AnnotationEntry annotation : field.getAnnotationEntries())  {
        if (ANNOTATION_TYPES.contains(annotation.getAnnotationType()) ||
                annotation.getAnnotationType().contains("JsonTypeInfo")) {
            for (ElementValuePair elementValuePair : annotation.getElementValuePairs()) {
                if ("use".equals((elementValuePair.getNameString())) &&
                        VULNERABLE_USE_NAMES.contains(elementValuePair.getValue().stringifyValue())) {
                    bugReporter.reportBug(new BugInstance(this, DESERIALIZATION_TYPE, HIGH_PRIORITY)
                            .addClass(javaClass)
                            .addString(javaClass.getClassName() + " on field " +
                                    field.getName() + " of type " + field.getType() +
                                    " annotated with " + annotation.toShortString())
                            .addField(FieldAnnotation.fromBCELField(javaClass, field))
                            .addString("")
                    );
                }
            }
        }
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
protected Field[] getFields(final ClassItem classItem, final boolean staticFields) {
  final Set<Field> fieldSet = new TreeSet<Field>(new Comparator<Field>() {

    @Override
    public int compare(final Field o1, final Field o2) {
      return o1.getName().compareTo(o2.getName());
    }
  });

  final Field[] fields = classItem.getJavaClass().getFields();
  for (final Field field : fields) {
    if (staticFields) {
      if (field.isStatic()) {
        fieldSet.add(field);
      }
    } else {
      if (!field.isStatic()) {
        fieldSet.add(field);
      }
    }
  }

  return fieldSet.toArray(new Field[fieldSet.size()]);
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
protected String field2str(final Field field) {
  String modifier = "";

  if (field.isPrivate()) {
    modifier = "private ";
  } else if (field.isProtected()) {
    modifier = "protected ";
  } else if (field.isPublic()) {
    modifier = "public ";
  }

  if (field.isStatic()) {
    modifier += "static ";
  }

  if (field.isFinal()) {
    modifier += "final ";
  }

  modifier += field.getType().toString();

  modifier += ' ' + field.getName();

  return modifier;
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/**
 * Collect valid fields of the wrapped class. Valid fields includes all
 * except private static and private transient.
 *
 * @param clazz
 *            - the wrapped class.
 * @return a {@link Vector} of valid fields.
 */
private Vector<Field> collectValidFields(JavaClass clazz) {
    Field[] allFields = clazz.getFields();
    Vector<Field> validFields = new Vector<Field>();
    suidField = null;

    int PRIVATE_STATIC = Modifier.PRIVATE | Modifier.STATIC;
    int PRIVATE_TRANSIENT = Modifier.PRIVATE | Modifier.TRANSIENT;

    // Excluding all PRIVATE_STATIC and PRIVATE_TRANSIENT fields
    for (int i = 0; i < allFields.length; i++) {
        if ((allFields[i].getModifiers() != PRIVATE_STATIC)
            && (allFields[i].getModifiers() != PRIVATE_TRANSIENT)) {
            // Adding
            validFields.add(allFields[i]);

            // Let's check if the Field is a existing SUID
            if (allFields[i].getName().equals("serialVersionUID")) {
                suidField = allFields[i];
            }
        }
    }
    return validFields;
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
private void doVisitField(Field field) {
    if (visitingField)
        throw new IllegalStateException("visitField called when already visiting a field");
    visitingField = true;
    this.field = field;
    try {
        fieldName = fieldSig = dottedFieldSig = fullyQualifiedFieldName = null;
        thisFieldInfo = (FieldInfo) thisClassInfo.findField(getFieldName(), getFieldSig(), field.isStatic());
        assert thisFieldInfo !=  null : "Can't get field info for " + getFullyQualifiedFieldName();
        fieldIsStatic = field.isStatic();
        field.accept(this);
        Attribute[] attributes = field.getAttributes();
        for (Attribute attribute : attributes)
            attribute.accept(this);
    } finally {
        visitingField = false;
        this.field = null;
        this.thisFieldInfo = null;
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
Field findField(String className, String fieldName) {
    try {
        // System.out.println("Looking for " + className);
        JavaClass fieldDefinedIn = getThisClass();
        if (!className.equals(getClassName())) {
            // System.out.println("Using repository to look for " +
            // className);

            fieldDefinedIn = Repository.lookupClass(className);
        }
        Field[] f = fieldDefinedIn.getFields();
        for (Field aF : f)
            if (aF.getName().equals(fieldName)) {
                // System.out.println("Found " + f[i]);
                return aF;
            }
        return null;
    } catch (ClassNotFoundException e) {
        return null;
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
@Override
public void visit(Field obj) {
    if (getFieldName().length() == 1)
        return;

    if (isEclipseNLS) {
        int flags = obj.getAccessFlags();
        if ((flags & ACC_STATIC) != 0 && ((flags & ACC_PUBLIC) != 0) && getFieldSig().equals("Ljava/lang/String;")) {
            // ignore "public statis String InstallIUCommandTooltip;"
            // messages from Eclipse NLS bundles
            return;
        }
    }
    if (badFieldName(obj)) {
        bugReporter.reportBug(new BugInstance(this, "NM_FIELD_NAMING_CONVENTION", classIsPublicOrProtected
                && (obj.isPublic() || obj.isProtected()) && !hasBadFieldNames ? NORMAL_PRIORITY : LOW_PRIORITY)
                .addClass(this).addVisitedField(this));
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/**
 * Find a field with given name defined in given class.
 * 
 * @param className
 *            the name of the class
 * @param fieldName
 *            the name of the field
 * @return the Field, or null if no such field could be found
 */
public static Field findField(String className, String fieldName) throws ClassNotFoundException {
    JavaClass jclass = Repository.lookupClass(className);

    while (jclass != null) {
        Field[] fieldList = jclass.getFields();
        for (Field field : fieldList) {
            if (field.getName().equals(fieldName)) {
                return field;
            }
        }

        jclass = jclass.getSuperClass();
    }

    return null;
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
public static boolean isJSP(JavaClass javaClass) {
    @DottedClassName String className = javaClass.getClassName();
    if ( className.endsWith("_jsp") || className.endsWith("_tag"))
        return true;
    for(Method m : javaClass.getMethods())
        if (m.getName().startsWith("_jsp"))
            return true;
    
    for(Field f : javaClass.getFields())
        if (f.getName().startsWith("_jsp"))
            return true;
    return Subtypes2.instanceOf(className, "javax.servlet.jsp.JspPage")
            || Subtypes2.instanceOf(className, "org.apache.jasper.runtime.HttpJspBase")
            || Subtypes2.instanceOf(className, "javax.servlet.jsp.tagext.SimpleTagSupport")
            || Subtypes2.instanceOf(className, " org.apache.jasper.runtime.JspSourceDependent");
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
@Override
public void visit(Field field) {
   if (!field.isStatic())
       return;
   String signature = field.getSignature();
   if (signature.startsWith("Ljava/util/") && !signature.equals("Ljava/util/regex/Pattern;")
           && !signature.equals("Ljava/util/logging/Logger;") && !signature.equals("Ljava/util/BitSet;")
           && !signature.equals("Ljava/util/ResourceBundle;")
           && !signature.equals("Ljava/util/Comparator;")
           && getXField().getAnnotation(ConstantAnnotation) == null) {
       boolean flagged = analysisContextContained(getXClass());

       bugReporter.reportBug(new BugInstance(this, "TESTING", flagged ? NORMAL_PRIORITY : LOW_PRIORITY).addClass(this).addField(this).addType(signature));

   }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/**
 * Find a field with given name defined in given class.
 *
 * @param className
 *            the name of the class
 * @param fieldName
 *            the name of the field
 * @return the Field, or null if no such field could be found
 */
public static Field findField(String className, String fieldName) throws ClassNotFoundException {
    JavaClass jclass = Repository.lookupClass(className);

    while (jclass != null) {
        Field[] fieldList = jclass.getFields();
        for (Field field : fieldList) {
            if (field.getName().equals(fieldName)) {
                return field;
            }
        }

        jclass = jclass.getSuperClass();
    }

    return null;
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/** Checks if the constraints of operands of the said instruction(s) are satisfied. */
public void visitGETSTATIC(GETSTATIC o){
    try {
	String field_name = o.getFieldName(cpg);
	JavaClass jc = Repository.lookupClass(o.getClassType(cpg).getClassName());
	Field[] fields = jc.getFields();
	Field f = null;
	for (int i=0; i<fields.length; i++){
		if (fields[i].getName().equals(field_name)){
			f = fields[i];
			break;
		}
	}
	if (f == null){
		throw new AssertionViolatedException("Field not found?!?");
	}

	if (! (f.isStatic())){
		constraintViolated(o, "Referenced field '"+f+"' is not static which it should be.");
	}
    } catch (ClassNotFoundException e) {
	// FIXME: maybe not the best way to handle this
	throw new AssertionViolatedException("Missing class: " + e.toString());
    }
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
MethodHTML(String dir, String class_name, Method[] methods, Field[] fields,
        ConstantHTML constant_html, AttributeHTML attribute_html) throws IOException {
    this.class_name = class_name;
    this.attribute_html = attribute_html;
    this.constant_html = constant_html;
    file = new PrintWriter(new FileOutputStream(dir + class_name + "_methods.html"));
    file.println("<HTML><BODY BGCOLOR=\"#C0C0C0\"><TABLE BORDER=0>");
    file.println("<TR><TH ALIGN=LEFT>Access&nbsp;flags</TH><TH ALIGN=LEFT>Type</TH>"
            + "<TH ALIGN=LEFT>Field&nbsp;name</TH></TR>");
    for (int i = 0; i < fields.length; i++) {
        writeField(fields[i]);
    }
    file.println("</TABLE>");
    file.println("<TABLE BORDER=0><TR><TH ALIGN=LEFT>Access&nbsp;flags</TH>"
            + "<TH ALIGN=LEFT>Return&nbsp;type</TH><TH ALIGN=LEFT>Method&nbsp;name</TH>"
            + "<TH ALIGN=LEFT>Arguments</TH></TR>");
    for (int i = 0; i < methods.length; i++) {
        writeMethod(methods[i], i);
    }
    file.println("</TABLE></BODY></HTML>");
    file.close();
}
 

import org.apache.bcel.classfile.Field; //导入依赖的package包/类
/**
 * Print field of class.
 *
 * @param field field to print
 * @exception java.io.IOException
 */
private void writeField( Field field ) throws IOException {
    String type = Utility.signatureToString(field.getSignature());
    String name = field.getName();
    String access = Utility.accessToString(field.getAccessFlags());
    Attribute[] attributes;
    access = Utility.replace(access, " ", " ");
    file.print("<TR><TD><FONT COLOR=\"#FF0000\">" + access + "</FONT></TD>\n<TD>"
            + Class2HTML.referenceType(type) + "</TD><TD><A NAME=\"field" + name + "\">" + name
            + "</A></TD>");
    attributes = field.getAttributes();
    // Write them to the Attributes.html file with anchor "<name>[<i>]"
    for (int i = 0; i < attributes.length; i++) {
        attribute_html.writeAttribute(attributes[i], name + "@" + i);
    }
    for (int i = 0; i < attributes.length; i++) {
        if (attributes[i].getTag() == ATTR_CONSTANT_VALUE) { // Default value
            String str = ((ConstantValue) attributes[i]).toString();
            // Reference attribute in _attributes.html
            file.print("<TD>= <A HREF=\"" + class_name + "_attributes.html#" + name + "@" + i
                    + "\" TARGET=\"Attributes\">" + str + "</TD>\n");
            break;
        }
    }
    file.println("</TR>");
}