Java Code Examples for org.apache.bcel.classfile.Field#isPrivate()

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;
}
 

/** @see com.puppycrawl.tools.checkstyle.bcel.IObjectSetVisitor */
public void visitObject(Object aJavaClass)
{
    final JavaClass javaClass = (JavaClass) aJavaClass;
    final String className = javaClass.getClassName();
    final JavaClass[] superClasses = javaClass.getSuperClasses();
    final Field[] fields = javaClass.getFields();
    // Check all fields
    for (int i = 0; i < fields.length; i++) {
        final Field field = fields[i];
        // Go through all superclasses
        for (int j = 0; j < superClasses.length; j++) {
            final JavaClass superClass = superClasses[j];
            final String superClassName = superClass.getClassName();
            final Field[] superClassFields = superClass.getFields();
            // Go through the filds of the superclasses
            for (int k = 0; k < superClassFields.length; k++) {
                final Field superClassField = superClassFields[k];
                if (!superClassField.isPrivate() &&
                    superClassField.getName().equals(field.getName()) &&
                    !ignore(className, field)) {
                    log(
                        javaClass,
                        0,
                        "hidden.inherited.field",
                        new Object[] {fields[i], superClassName});
                }
            }
        }
    }
}
 

/** @see com.puppycrawl.tools.checkstyle.bcel.IObjectSetVisitor */
public void visitObject(Object aJavaClass)
{
    final JavaClass javaClass = (JavaClass) aJavaClass;
    final String className = javaClass.getClassName();
    final JavaClass[] superClasses = javaClass.getSuperClasses();
    final Field[] fields = javaClass.getFields();
    // Check all fields
    for (int i = 0; i < fields.length; i++) {
        final Field field = fields[i];
        // Go through all superclasses
        for (int j = 0; j < superClasses.length; j++) {
            final JavaClass superClass = superClasses[j];
            final String superClassName = superClass.getClassName();
            final Field[] superClassFields = superClass.getFields();
            // Go through the filds of the superclasses
            for (int k = 0; k < superClassFields.length; k++) {
                final Field superClassField = superClassFields[k];
                if (!superClassField.isPrivate() &&
                    superClassField.getName().equals(field.getName()) &&
                    !ignore(className, field)) {
                    log(
                        javaClass,
                        0,
                        "hidden.inherited.field",
                        new Object[] {fields[i], superClassName});
                }
            }
        }
    }
}
 

/**
 * Checks if the visited field is of type {@link java.util.Calendar} or
 * {@link java.text.DateFormat} or a subclass of either one. If so and the
 * field is static and non-private it is suspicious and will be reported.
 */
@Override
public void visit(Field aField) {
    if (aField.isPrivate()) {
        /*
         * private fields are harmless, as long as they are used correctly
         * inside their own class. This should be something the rest of this
         * detector can find out, so do not report them, they might be false
         * positives.
         */
        return;
    }
    String superclassName = getSuperclassName();
    if (!aField.isStatic() && !"java/lang/Enum".equals(superclassName)) {
        return;
    }
    if (!aField.isPublic() && !aField.isProtected()) {
        return;
    }
    ClassDescriptor classOfField = DescriptorFactory.createClassDescriptorFromFieldSignature(aField.getSignature());
    String tBugType = null;
    int priority = aField.isPublic() && aField.isFinal() && aField.getName().equals(aField.getName().toUpperCase())
            && getThisClass().isPublic() ? HIGH_PRIORITY : NORMAL_PRIORITY;
    if (classOfField != null) {
        try {
            if (subtypes2.isSubtype(classOfField, calendarType)) {
                tBugType = "STCAL_STATIC_CALENDAR_INSTANCE";
                priority++;
            } else if (subtypes2.isSubtype(classOfField, dateFormatType)) {
                tBugType = "STCAL_STATIC_SIMPLE_DATE_FORMAT_INSTANCE";
            }
            if (getClassContext().getXClass().usesConcurrency()) {
                priority--;
            }
            if (tBugType != null) {

                pendingBugs.put(getXField(), new BugInstance(this, tBugType, priority).addClass(currentClass).addField(this));
            }
        } catch (ClassNotFoundException e) {
            AnalysisContext.reportMissingClass(e);
        }
    }

}
 

@Override
public void visit(JavaClass obj) {
    classFields.clear();

    Field[] fields = obj.getFields();
    String fieldName;
    for (Field field : fields) {
        if (!field.isStatic() && !field.isPrivate()) {
            fieldName = field.getName();
            classFields.put(fieldName, field);
        }
    }

    // Walk up the super class chain, looking for name collisions

    XClass c = getXClass();
    while (true) {
        ClassDescriptor s = c.getSuperclassDescriptor();
        if (s == null || "java/lang/Object".equals(s.getClassName())) {
            break;
        }
        try {
            c = Global.getAnalysisCache().getClassAnalysis(XClass.class, s);
        } catch (CheckedAnalysisException e) {
            break;
        }

        for (XField fld : c.getXFields()) {
            if (!fld.isStatic() && (fld.isPublic() || fld.isProtected())) {
                fieldName = fld.getName();
                if (fieldName.length() == 1) {
                    continue;
                }
                if ("serialVersionUID".equals(fieldName)) {
                    continue;
                }
                String superClassName = s.getClassName();
                if (superClassName.startsWith("java/io")
                        && (superClassName.endsWith("InputStream") && "in".equals(fieldName) || superClassName
                                .endsWith("OutputStream") && "out".equals(fieldName))) {
                    continue;
                }
                if (classFields.containsKey(fieldName)) {
                    Field maskingField = classFields.get(fieldName);
                    String mClassName = getDottedClassName();
                    FieldAnnotation fa = new FieldAnnotation(mClassName, maskingField.getName(), maskingField.getSignature(),
                            maskingField.isStatic());
                    int priority = NORMAL_PRIORITY;
                    if (maskingField.isStatic() || maskingField.isFinal()) {
                        priority++;
                    } else if (fld.getSignature().charAt(0) == 'L' && !fld.getSignature().startsWith("Ljava/lang/")
                            || fld.getSignature().charAt(0) == '[') {
                        priority--;
                    }
                    if (!fld.getSignature().equals(maskingField.getSignature())) {
                        priority += 2;
                    } else if (fld.getAccessFlags() != maskingField.getAccessFlags()) {
                        priority++;
                    }
                    if (fld.isSynthetic() || fld.getName().indexOf('$') >= 0) {
                        priority++;
                    }

                    FieldAnnotation maskedFieldAnnotation = FieldAnnotation.fromFieldDescriptor(fld.getFieldDescriptor());
                    BugInstance bug = new BugInstance(this, "MF_CLASS_MASKS_FIELD", priority).addClass(this).addField(fa)
                            .describe("FIELD_MASKING").addField(maskedFieldAnnotation).describe("FIELD_MASKED");
                    rememberedBugs.add(new RememberedBug(bug, fa, maskedFieldAnnotation));

                }
            }
        }
    }

    super.visit(obj);
}
 

@Override
public void visitField(final Field obj) {

    if (jc.isClass()) {
        int maxone=0;
        if (obj.isPrivate()) {
            maxone++;
        }
        if (obj.isProtected()) {
            maxone++;
        }
        if (obj.isPublic()) {
            maxone++;
        }
        if (maxone > 1) {
            throw new ClassConstraintException("Field '"+tostring(obj)+
                "' must only have at most one of its ACC_PRIVATE, ACC_PROTECTED, ACC_PUBLIC modifiers set.");
        }

        if (obj.isFinal() && obj.isVolatile()) {
            throw new ClassConstraintException("Field '"+tostring(obj)+
                "' must only have at most one of its ACC_FINAL, ACC_VOLATILE modifiers set.");
        }
    }
    else{ // isInterface!
        if (!obj.isPublic()) {
            throw new ClassConstraintException("Interface field '"+tostring(obj)+
                "' must have the ACC_PUBLIC modifier set but hasn't!");
        }
        if (!obj.isStatic()) {
            throw new ClassConstraintException("Interface field '"+tostring(obj)+
                "' must have the ACC_STATIC modifier set but hasn't!");
        }
        if (!obj.isFinal()) {
            throw new ClassConstraintException("Interface field '"+tostring(obj)+
                "' must have the ACC_FINAL modifier set but hasn't!");
        }
    }

    if ((obj.getAccessFlags() & ~(Const.ACC_PUBLIC|Const.ACC_PRIVATE|Const.ACC_PROTECTED|Const.ACC_STATIC|
                                  Const.ACC_FINAL|Const.ACC_VOLATILE|Const.ACC_TRANSIENT)) > 0) {
        addMessage("Field '"+tostring(obj)+
            "' has access flag(s) other than ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED,"+
                " ACC_STATIC, ACC_FINAL, ACC_VOLATILE, ACC_TRANSIENT set (ignored).");
    }

    checkIndex(obj, obj.getNameIndex(), CONST_Utf8);

    final String name = obj.getName();
    if (! validFieldName(name)) {
        throw new ClassConstraintException("Field '"+tostring(obj)+"' has illegal name '"+obj.getName()+"'.");
    }

    // A descriptor is often named signature in BCEL
    checkIndex(obj, obj.getSignatureIndex(), CONST_Utf8);

    final String sig  = ((ConstantUtf8) (cp.getConstant(obj.getSignatureIndex()))).getBytes(); // Field or Method sig.(=descriptor)

    try{
        Type.getType(sig);  /* Don't need the return value */
    }
    catch (final ClassFormatException cfe) {
        throw new ClassConstraintException("Illegal descriptor (==signature) '"+sig+"' used by '"+tostring(obj)+"'.", cfe);
    }

    final String nameanddesc = name+sig;
    if (field_names_and_desc.contains(nameanddesc)) {
        throw new ClassConstraintException("No two fields (like '"+tostring(obj)+
            "') are allowed have same names and descriptors!");
    }
    if (field_names.contains(name)) {
        addMessage("More than one field of name '"+name+
            "' detected (but with different type descriptors). This is very unusual.");
    }
    field_names_and_desc.add(nameanddesc);
    field_names.add(name);

    final Attribute[] atts = obj.getAttributes();
    for (final Attribute att : atts) {
        if ((!(att instanceof ConstantValue)) &&
                (!(att instanceof Synthetic)) &&
                (!(att instanceof Deprecated))) {
            addMessage("Attribute '" + tostring(att) + "' as an attribute of Field '" +
                tostring(obj) + "' is unknown and will therefore be ignored.");
        }
        if (!(att instanceof ConstantValue)) {
            addMessage("Attribute '" + tostring(att) + "' as an attribute of Field '" + tostring(obj) +
                "' is not a ConstantValue and is therefore only of use for debuggers and such.");
        }
    }
}