import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
/**
 * Returns a string representation of a given object native value.
 * 
 * @param type - a Class object that wraps a data type.
 * @param value - an object that wraps a value of a primitive data type.
 * @return a string that represents a native data type.
 */
public static String getNativeValue(Type type, ConstantValue value) {
    StringBuffer result = new StringBuffer();

    if (type == Type.INT) {
        result.append(value.toString()).append('L');
    } else if (type == Type.BYTE) {
        result.append(value.toString()).append('L');
    } else if (type == Type.LONG) {
        result.append(value.toString()).append("LL");
    } else if (type == Type.FLOAT) {
        result.append(value.toString()).append('f');
    } else if (type == Type.DOUBLE) {
        result.append(value.toString());
    } else if (type == Type.SHORT) {
        result.append(value.toString()).append('L');
    } else if (type == Type.CHAR) {
        result.append(value.toString()).append('L');
    } else if (type == Type.BOOLEAN) {
        result.append(value.toString()).append('L');
    }

    return result.toString();
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
@Override
public void visit(ConstantValue s) {
    if (!visitingField())
        return;
    int i = s.getConstantValueIndex();
    Constant c = getConstantPool().getConstant(i);
    if (c instanceof ConstantString) {
        String value = ((ConstantString) c).getBytes(getConstantPool());
        if (value.length() < SIZE_OF_HUGE_CONSTANT)
            return;
        String key = getStringKey(value);
        definition.put(key, XFactory.createXField(this));
        stringSize.put(key, value.length());
    }

}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的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>");
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
/**
 * Get the constants declared in a file as name=value
 *
 * @param bytes the class as a array of bytes
 * @return a StringBuffer contains the name=value pairs
 * @exception IOException if an error occurs
 */
public static StringBuffer getConstants(final byte[] bytes)
    throws IOException {
    final StringBuffer sb = new StringBuffer();
    final ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
    final ClassParser parser = new ClassParser(bis, "");
    final JavaClass javaClass = parser.parse();
    final Field[] fields = javaClass.getFields();
    for (int i = 0; i < fields.length; i++) {
        final Field field = fields[i];
        if (field != null) {
            final ConstantValue cv = field.getConstantValue();
            if (cv != null) {
                String cvs = cv.toString();
                //Remove start and end quotes if field is a String
                if (cvs.startsWith("\"") && cvs.endsWith("\"")) {
                    cvs = cvs.substring(1, cvs.length() - 1);
                }
                sb.append(field.getName());
                sb.append('=');
                sb.append(cvs);
                sb.append(LS);
            }
        }
    }
    return sb;
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
@Override
public void visitField(Field field) {
    Element f = new Element("field", nsXMLVM);
    xmlClass.addContent(f);
    addAccessModifiers(f, field.getAccessFlags());
    f.setAttribute("name", field.getName());
    Type t = field.getType();
    f.setAttribute("type", t.toString());
    ConstantValue val = field.getConstantValue();
    if (val != null) {
        f.setAttribute("value", val.toString());
    }
    addAnnotations(f, field.getAnnotationEntries());
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
@Override
public void visit(Field field) {
    ConstantValue value = field.getConstantValue();
    if (value == null) return;
    Constant c = getConstantPool().getConstant(value.getConstantValueIndex());

    if (c instanceof ConstantLong && ((ConstantLong)c).getBytes()  == MICROS_PER_DAY_OVERFLOWED_AS_INT) {
        bugReporter.reportBug( new BugInstance(this, "TESTING", HIGH_PRIORITY).addClass(this).addField(this)
        .addString("Did you mean MICROS_PER_DAY")
        .addInt(MICROS_PER_DAY_OVERFLOWED_AS_INT)
        .describe(IntAnnotation.INT_VALUE));

    }
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
@Override
public void visit(ConstantValue obj) {
    // ConstantValue is an attribute of a field, so the instance variables
    // set during visitation of the Field are still valid here
    XField f = XFactory.createXField(this);
    data.constantFields.add(f);
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
/**
 * Instantiate from existing field.
 *
 * @param field Field object
 * @param cp constant pool (must contain the same entries as the field's constant pool)
 */
public FieldGen(Field field, ConstantPoolGen cp) {
    this(field.getAccessFlags(), Type.getType(field.getSignature()), field.getName(), cp);
    Attribute[] attrs = field.getAttributes();
    for (int i = 0; i < attrs.length; i++) {
        if (attrs[i] instanceof ConstantValue) {
            setValue(((ConstantValue) attrs[i]).getConstantValueIndex());
        } else {
            addAttribute(attrs[i]);
        }
    }
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
/**
 * Get field object after having set up all necessary values.
 */
public Field getField() {
    String signature = getSignature();
    int name_index = cp.addUtf8(name);
    int signature_index = cp.addUtf8(signature);
    if (value != null) {
        checkType(type);
        int index = addConstant();
        addAttribute(new ConstantValue(cp.addUtf8("ConstantValue"), 2, index, cp
                .getConstantPool()));
    }
    return new Field(access_flags, name_index, signature_index, getAttributes(), cp
            .getConstantPool());
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitField( Field field ) {
    _out.println();
    _out.println("    field = new FieldGen(" + printFlags(field.getAccessFlags()) + ", "
            + printType(field.getSignature()) + ", \"" + field.getName() + "\", _cp);");
    ConstantValue cv = field.getConstantValue();
    if (cv != null) {
        String value = cv.toString();
        _out.println("    field.setInitValue(" + value + ")");
    }
    _out.println("    _cg.addField(field.getField());");
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitConstantValue(ConstantValue cv) {
  out.println(" = " + cv);
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
/**
 * Returns some information about the class fields.
 * 
 * @param indent - an indentation.
 * @return an indented string with some information about the class fields.
 */
private String printFields(int indent) {
    StringBuffer result = new StringBuffer();

    Field fields[] = wrappedClass.getFields();
    if (fields.length > 0) {
        // Create the indentation string.
        String indentStr = indentString(indent);

        boolean found = false;
        for (int i = 0; i < fields.length; i++) {
            Field f = fields[i];

            // Skip a field, if we should not print an information about it.
            if (!isPrintable(f)) {
                continue;
            }
            found = true;

            result.append(n);
            result.append(indentStr);

            // Append an access string.
            String access = Utility.accessToString(f.getAccessFlags());
            if (access.length() > 0) {
                result.append(access);
                result.append(' ');
            }
            // Append a field signature and name.
            result.append(Utility.signatureToString(f.getSignature()));
            result.append(' ');
            result.append(f.getName());
            result.append(';');
            result.append(n);

            // Append a type signature.
            if (printTypeSignatures) {
                result.append(indentString(indent * 2, "Signature: "));
                result.append(f.getSignature());
                result.append(n);
            }

            if (verbose) {
                // Append a field constant value, if any.
                ConstantValue cv  = f.getConstantValue();
                if (cv != null) {
                    result.append(indentString(indent * 2,
                            "Constant value: "));
                    result.append(cv);
                    result.append(n);
                }

                Attribute attrs[] = f.getAttributes();
                for (int j = 0; j < attrs.length; j++) {
                    if (attrs[j].getTag() == Constants.ATTR_SYNTHETIC) {
                        result.append(indentString(indent * 2, 
                                "Synthetic: true"));
                        result.append(n);
                        break;
                    }
                }
            }

        }
        if (found) {
            result.append(n);
        }
    }
    return result.toString();
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
@Override
public void visitConstantValue(ConstantValue cv) {
    // System.out.println("**************** = " + cv);
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visit(ConstantValue obj) {
    visit((Attribute) obj);
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitConstantValue(ConstantValue obj) {
    visit(obj);
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitField(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() & ~(ACC_PUBLIC|ACC_PRIVATE|ACC_PROTECTED|ACC_STATIC|ACC_FINAL|ACC_VOLATILE|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);

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

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

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

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

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

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitConstantValue(ConstantValue obj){//vmspec2 4.7.2
	// Despite its name, this really is an Attribute,
	// not a constant!
	checkIndex(obj, obj.getNameIndex(), CONST_Utf8);

	String name = ((ConstantUtf8) cp.getConstant(obj.getNameIndex())).getBytes();
	if (! name.equals("ConstantValue")){
		throw new ClassConstraintException("The ConstantValue attribute '"+tostring(obj)+"' is not correctly named 'ConstantValue' but '"+name+"'.");
	}

	Object pred = carrier.predecessor();
	if (pred instanceof Field){ //ConstantValue attributes are quite senseless if the predecessor is not a field.
		Field f = (Field) pred;
		// Field constraints have been checked before -- so we are safe using their type information.
		Type field_type = Type.getType(((ConstantUtf8) (cp.getConstant(f.getSignatureIndex()))).getBytes());

		int index = obj.getConstantValueIndex();
		if ((index < 0) || (index >= cplen)){
			throw new ClassConstraintException("Invalid index '"+index+"' used by '"+tostring(obj)+"'.");
		}
		Constant c = cp.getConstant(index);

		if (CONST_Long.isInstance(c) && field_type.equals(Type.LONG)){
			return;
		}
		if (CONST_Float.isInstance(c) && field_type.equals(Type.FLOAT)){
			return;
		}
		if (CONST_Double.isInstance(c) && field_type.equals(Type.DOUBLE)){
			return;
		}
		if (CONST_Integer.isInstance(c) && (field_type.equals(Type.INT) || field_type.equals(Type.SHORT) || field_type.equals(Type.CHAR) || field_type.equals(Type.BYTE) || field_type.equals(Type.BOOLEAN))){
			return;
		}
		if (CONST_String.isInstance(c) && field_type.equals(Type.STRING)){
			return;
		}

		throw new ClassConstraintException("Illegal type of ConstantValue '"+obj+"' embedding Constant '"+c+"'. It is referenced by field '"+tostring(f)+"' expecting a different type: '"+field_type+"'.");
	}
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitConstantValue(ConstantValue obj) {
    tostring = toString(obj);
}
 

import org.apache.bcel.classfile.ConstantValue; //导入依赖的package包/类
public void visitConstantValue(ConstantValue cv) {
	out.println(" = " + cv);
}