@Override
public void parseSelf(AttributeInfo attributeInfo, List<ConstantPoolInfo> cp_info)
throws Exception {
super.parseSelf(attributeInfo, cp_info);
byte[] info = attributeInfo.getInfo();
int[] index = new int[] {0};
setNum_parameters(TransformUtil.subBytes(info, index, 1)[0]);
int num_param = TransformUtil.bytesToInt(new byte[] {getNum_parameters()});
if (num_param > 0) {
List<Parameter> parameters = new ArrayList<Parameter>();
for (int i = 0; i < num_param; i++) {
Parameter parameter = new Parameter();
parameter.setNum_annotations(TransformUtil.subBytes(info, index, 2));
int num_anno = TransformUtil.bytesToInt(parameter.getNum_annotations());
if (num_anno > 0) {
List<Annotation> annotations = new ArrayList<Annotation>();
for (int j = 0; j < num_anno; j++) {
Annotation annotation = new Annotation(cp_info);
annotation.parseSelf(info, index);
annotations.add(annotation);
}
parameter.setAnnotations(annotations);
}
setParameters(parameters);
}
}
}
private void mergeDataObjects(DataObjectInfo keep, DataObjectInfo merge) {
for (AttributeInfo attr : merge.getAttributeDefs()) {
if (keep.getAttributeDef(attr.getAttrName()) == null) {
attr.setParentDataObject(keep);
keep.addAttribute(attr);
}
}
if (keep.getFindAllMethod() == null) {
keep.setFindAllMethod(merge.getFindAllMethod());
}
if (keep.getFindMethod() == null) {
keep.setFindMethod(merge.getFindMethod());
}
if (keep.getGetCanonicalMethod() == null) {
keep.setGetCanonicalMethod(merge.getGetCanonicalMethod());
}
if (keep.getCreateMethod() == null) {
keep.setCreateMethod(merge.getCreateMethod());
}
if (keep.getUpdateMethod() == null) {
keep.setUpdateMethod(merge.getUpdateMethod());
}
if (keep.getMergeMethod() == null) {
keep.setMergeMethod(merge.getMergeMethod());
}
if (keep.getDeleteMethod() == null) {
keep.setDeleteMethod(merge.getDeleteMethod());
}
// move child accessors to "keep" data object"
for (AccessorInfo accessor : merge.getAllChildren()) {
if (keep.findChildAccessor(accessor.getChildAccessorName()) == null) {
accessor.setParentDataObject(keep);
keep.addChild(accessor);
}
}
// loop over all other data objects, and check if they have a child accessor with the "merge"
// data object as child. If so, move the pointer from "merge" to "keep" data object
// NOTE: we should not loop over getSelectedDataObjectInfo, would cause infinite loop
// as this method is called from getSelectedDataObjectInfos
for (DataObjectInfo doi : this.getDataObjectInfos()) {
for (AccessorInfo accessor : doi.getAllChildren()) {
if (accessor.getChildDataObject() == merge) {
accessor.setChildDataObject(keep);
// if there is a child accessor method, we also need to add that "find-in=parent method to
// "keep" doi!
if (accessor.getChildAccessorMethod() != null) {
keep.addFindAllInParentMethod(accessor.getChildAccessorMethod());
}
}
}
// also check the parameterValueProvider objects for methods
for (DCMethod method : doi.getAllMethods()) {
if (merge == method.getParameterValueProviderDataObject()) {
method.setParameterValueProviderDataObject(keep);
}
}
}
}
public AttributeInfo getAtrribute(String name) {
NOTNULL(name);
for (AttributeInfo a : attributes()) {
if (a.name().equals(name)) {
return a;
}
}
return null;
}
private void registerConstants(ConstantPool pool) {
classname = pool.register(classname);
superclass = pool.register(superclass);
interfaces = Helper.register(interfaces, pool);
for (FieldInfo f : iterable(fields)) {
f.registerConstants(pool);
}
for (MethodInfo m : iterable(methods)) {
m.registerConstants(pool);
}
for (AttributeInfo a : iterable(attributes)) {
a.registerConstants(pool);
}
pool.rebuild();
}
private AttributeInfo parseAttribute() throws IOException {
AttributeInfo result = new AttributeInfo();
int nameIndex = in.readUnsignedShort();
if (nameIndex != -1) {
result.setName(toUTF8(nameIndex));
}
int attributeLength = in.readInt();
byte[] value = new byte[attributeLength];
for (int b = 0; b < attributeLength; b++) {
value[b] = in.readByte();
}
result.setValue(value);
return result;
}
private void read(DataInputStream in) throws IOException {
accessFlags = in.readUnsignedShort();
name = in.readUnsignedShort();
descriptor = in.readUnsignedShort();
int n = in.readUnsignedShort();
attribute = new LinkedList();
for (int i = 0; i < n; ++i) attribute.add(AttributeInfo.read(constPool, in));
}
void write(DataOutputStream out) throws IOException {
out.writeShort(accessFlags);
out.writeShort(name);
out.writeShort(descriptor);
if (attribute == null) out.writeShort(0);
else {
out.writeShort(attribute.size());
AttributeInfo.writeAll(attribute, out);
}
}
void prune(ConstPool cp) {
LinkedList newAttributes = new LinkedList();
AttributeInfo invisibleAnnotations = getAttribute(AnnotationsAttribute.invisibleTag);
if (invisibleAnnotations != null) {
invisibleAnnotations = invisibleAnnotations.copy(cp, null);
newAttributes.add(invisibleAnnotations);
}
AttributeInfo visibleAnnotations = getAttribute(AnnotationsAttribute.visibleTag);
if (visibleAnnotations != null) {
visibleAnnotations = visibleAnnotations.copy(cp, null);
newAttributes.add(visibleAnnotations);
}
AttributeInfo signature = getAttribute(SignatureAttribute.tag);
if (signature != null) {
signature = signature.copy(cp, null);
newAttributes.add(signature);
}
int index = getConstantValue();
if (index != 0) {
index = constPool.copy(index, cp, null);
newAttributes.add(new ConstantAttribute(cp, index));
}
attribute = newAttributes;
name = cp.addUtf8Info(getName());
descriptor = cp.addUtf8Info(getDescriptor());
constPool = cp;
}
static void printAttributes(List<AttributeInfo> list, PrintWriter out, char kind) {
if (list == null) {
return;
}
int n = list.size();
for (int i = 0; i < n; ++i) {
AttributeInfo ai = list.get(i);
if (ai instanceof CodeAttribute) {
CodeAttribute ca = (CodeAttribute) ai;
out.println("attribute: " + ai.getName() + ": " + ai.getClass().getName());
out.println(
"max stack "
+ ca.getMaxStack()
+ ", max locals "
+ ca.getMaxLocals()
+ ", "
+ ca.getExceptionTable().size()
+ " catch blocks");
out.println("<code attribute begin>");
printAttributes(ca.getAttributes(), out, kind);
out.println("<code attribute end>");
} else if (ai instanceof org.hotswap.agent.javassist.bytecode.AnnotationsAttribute) {
out.println("annnotation: " + ai.toString());
} else if (ai instanceof org.hotswap.agent.javassist.bytecode.ParameterAnnotationsAttribute) {
out.println("parameter annnotations: " + ai.toString());
} else if (ai instanceof org.hotswap.agent.javassist.bytecode.StackMapTable) {
out.println("<stack map table begin>");
org.hotswap.agent.javassist.bytecode.StackMapTable.Printer.print(
(org.hotswap.agent.javassist.bytecode.StackMapTable) ai, out);
out.println("<stack map table end>");
} else if (ai instanceof org.hotswap.agent.javassist.bytecode.StackMap) {
out.println("<stack map begin>");
((org.hotswap.agent.javassist.bytecode.StackMap) ai).print(out);
out.println("<stack map end>");
} else if (ai instanceof org.hotswap.agent.javassist.bytecode.SignatureAttribute) {
org.hotswap.agent.javassist.bytecode.SignatureAttribute sa =
(org.hotswap.agent.javassist.bytecode.SignatureAttribute) ai;
String sig = sa.getSignature();
out.println("signature: " + sig);
try {
String s;
if (kind == 'c') {
s =
org.hotswap.agent.javassist.bytecode.SignatureAttribute.toClassSignature(sig)
.toString();
} else if (kind == 'm') {
s =
org.hotswap.agent.javassist.bytecode.SignatureAttribute.toMethodSignature(sig)
.toString();
} else {
s =
org.hotswap.agent.javassist.bytecode.SignatureAttribute.toFieldSignature(sig)
.toString();
}
out.println(" " + s);
} catch (org.hotswap.agent.javassist.bytecode.BadBytecode e) {
out.println(" syntax error");
}
} else {
out.println(
"attribute: "
+ ai.getName()
+ " ("
+ ai.get().length
+ " byte): "
+ ai.getClass().getName());
}
}
}
/**
* Copies all constant pool items to a given new constant pool and replaces the original items
* with the new ones. This is used for garbage collecting the items of removed fields and methods.
*
* @param cp the destination
*/
void compact(ConstPool cp) {
name = cp.addUtf8Info(getName());
descriptor = cp.addUtf8Info(getDescriptor());
attribute = AttributeInfo.copyAll(attribute, cp);
constPool = cp;
}
/**
* Appends an attribute. If there is already an attribute with the same name, the new one
* substitutes for it.
*
* @see #getAttributes()
*/
public void addAttribute(AttributeInfo info) {
if (attribute == null) attribute = new LinkedList();
AttributeInfo.remove(attribute, info.getName());
attribute.add(info);
}
/**
* Returns the attribute with the specified name. It returns null if the specified attribute is
* not found.
*
* @param name attribute name
* @see #getAttributes()
*/
public AttributeInfo getAttribute(String name) {
return AttributeInfo.lookup(attribute, name);
}
/**
* @return
* @throws BasicException
*/
@Override
public Object createValue() throws BasicException {
AttributeInfo att = (AttributeInfo) attmodel.getSelectedItem();
return att == null ? null : att.getId();
}
