Java example source code file (AttributeWriter.java)
The AttributeWriter.java Java example source code/*
* Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.tools.javap;
import java.util.Formatter;
import com.sun.tools.classfile.AccessFlags;
import com.sun.tools.classfile.AnnotationDefault_attribute;
import com.sun.tools.classfile.Attribute;
import com.sun.tools.classfile.Attributes;
import com.sun.tools.classfile.BootstrapMethods_attribute;
import com.sun.tools.classfile.CharacterRangeTable_attribute;
import com.sun.tools.classfile.Code_attribute;
import com.sun.tools.classfile.CompilationID_attribute;
import com.sun.tools.classfile.ConstantPool;
import com.sun.tools.classfile.ConstantPoolException;
import com.sun.tools.classfile.ConstantValue_attribute;
import com.sun.tools.classfile.DefaultAttribute;
import com.sun.tools.classfile.Deprecated_attribute;
import com.sun.tools.classfile.EnclosingMethod_attribute;
import com.sun.tools.classfile.Exceptions_attribute;
import com.sun.tools.classfile.InnerClasses_attribute;
import com.sun.tools.classfile.LineNumberTable_attribute;
import com.sun.tools.classfile.LocalVariableTable_attribute;
import com.sun.tools.classfile.LocalVariableTypeTable_attribute;
import com.sun.tools.classfile.MethodParameters_attribute;
import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;
import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;
import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;
import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;
import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;
import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;
import com.sun.tools.classfile.Signature_attribute;
import com.sun.tools.classfile.SourceDebugExtension_attribute;
import com.sun.tools.classfile.SourceFile_attribute;
import com.sun.tools.classfile.SourceID_attribute;
import com.sun.tools.classfile.StackMapTable_attribute;
import com.sun.tools.classfile.StackMap_attribute;
import com.sun.tools.classfile.Synthetic_attribute;
import static com.sun.tools.classfile.AccessFlags.*;
/*
* A writer for writing Attributes as text.
*
* <p>This is NOT part of any supported API.
* If you write code that depends on this, you do so at your own risk.
* This code and its internal interfaces are subject to change or
* deletion without notice.</b>
*/
public class AttributeWriter extends BasicWriter
implements Attribute.Visitor<Void,Void>
{
public static AttributeWriter instance(Context context) {
AttributeWriter instance = context.get(AttributeWriter.class);
if (instance == null)
instance = new AttributeWriter(context);
return instance;
}
protected AttributeWriter(Context context) {
super(context);
context.put(AttributeWriter.class, this);
annotationWriter = AnnotationWriter.instance(context);
codeWriter = CodeWriter.instance(context);
constantWriter = ConstantWriter.instance(context);
options = Options.instance(context);
}
public void write(Object owner, Attribute attr, ConstantPool constant_pool) {
if (attr != null) {
// null checks
owner.getClass();
constant_pool.getClass();
this.constant_pool = constant_pool;
this.owner = owner;
attr.accept(this, null);
}
}
public void write(Object owner, Attributes attrs, ConstantPool constant_pool) {
if (attrs != null) {
// null checks
owner.getClass();
constant_pool.getClass();
this.constant_pool = constant_pool;
this.owner = owner;
for (Attribute attr: attrs)
attr.accept(this, null);
}
}
public Void visitDefault(DefaultAttribute attr, Void ignore) {
if (attr.reason != null) {
report(attr.reason);
}
byte[] data = attr.info;
int i = 0;
int j = 0;
print(" ");
try {
print(attr.getName(constant_pool));
} catch (ConstantPoolException e) {
report(e);
print("attribute name = #" + attr.attribute_name_index);
}
print(": ");
println("length = 0x" + toHex(attr.info.length));
print(" ");
while (i < data.length) {
print(toHex(data[i], 2));
j++;
if (j == 16) {
println();
print(" ");
j = 0;
} else {
print(" ");
}
i++;
}
println();
return null;
}
public Void visitAnnotationDefault(AnnotationDefault_attribute attr, Void ignore) {
println("AnnotationDefault:");
indent(+1);
print("default_value: ");
annotationWriter.write(attr.default_value);
indent(-1);
return null;
}
public Void visitBootstrapMethods(BootstrapMethods_attribute attr, Void p) {
println(Attribute.BootstrapMethods + ":");
for (int i = 0; i < attr.bootstrap_method_specifiers.length ; i++) {
BootstrapMethods_attribute.BootstrapMethodSpecifier bsm = attr.bootstrap_method_specifiers[i];
indent(+1);
print(i + ": #" + bsm.bootstrap_method_ref + " ");
println(constantWriter.stringValue(bsm.bootstrap_method_ref));
indent(+1);
println("Method arguments:");
indent(+1);
for (int j = 0; j < bsm.bootstrap_arguments.length; j++) {
print("#" + bsm.bootstrap_arguments[j] + " ");
println(constantWriter.stringValue(bsm.bootstrap_arguments[j]));
}
indent(-3);
}
return null;
}
public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, Void ignore) {
println("CharacterRangeTable:");
indent(+1);
for (int i = 0; i < attr.character_range_table.length; i++) {
CharacterRangeTable_attribute.Entry e = attr.character_range_table[i];
print(String.format(" %2d, %2d, %6x, %6x, %4x",
e.start_pc, e.end_pc,
e.character_range_start, e.character_range_end,
e.flags));
tab();
print(String.format("// %2d, %2d, %4d:%02d, %4d:%02d",
e.start_pc, e.end_pc,
(e.character_range_start >> 10), (e.character_range_start & 0x3ff),
(e.character_range_end >> 10), (e.character_range_end & 0x3ff)));
if ((e.flags & CharacterRangeTable_attribute.CRT_STATEMENT) != 0)
print(", statement");
if ((e.flags & CharacterRangeTable_attribute.CRT_BLOCK) != 0)
print(", block");
if ((e.flags & CharacterRangeTable_attribute.CRT_ASSIGNMENT) != 0)
print(", assignment");
if ((e.flags & CharacterRangeTable_attribute.CRT_FLOW_CONTROLLER) != 0)
print(", flow-controller");
if ((e.flags & CharacterRangeTable_attribute.CRT_FLOW_TARGET) != 0)
print(", flow-target");
if ((e.flags & CharacterRangeTable_attribute.CRT_INVOKE) != 0)
print(", invoke");
if ((e.flags & CharacterRangeTable_attribute.CRT_CREATE) != 0)
print(", create");
if ((e.flags & CharacterRangeTable_attribute.CRT_BRANCH_TRUE) != 0)
print(", branch-true");
if ((e.flags & CharacterRangeTable_attribute.CRT_BRANCH_FALSE) != 0)
print(", branch-false");
println();
}
indent(-1);
return null;
}
public Void visitCode(Code_attribute attr, Void ignore) {
codeWriter.write(attr, constant_pool);
return null;
}
public Void visitCompilationID(CompilationID_attribute attr, Void ignore) {
constantWriter.write(attr.compilationID_index);
return null;
}
public Void visitConstantValue(ConstantValue_attribute attr, Void ignore) {
if (options.compat) // BUG 6622216 javap names some attributes incorrectly
print("Constant value: ");
else
print("ConstantValue: ");
constantWriter.write(attr.constantvalue_index);
println();
return null;
}
public Void visitDeprecated(Deprecated_attribute attr, Void ignore) {
println("Deprecated: true");
return null;
}
public Void visitEnclosingMethod(EnclosingMethod_attribute attr, Void ignore) {
print("EnclosingMethod: #" + attr.class_index + ".#" + attr.method_index);
tab();
print("// " + getJavaClassName(attr));
if (attr.method_index != 0)
print("." + getMethodName(attr));
println();
return null;
}
private String getJavaClassName(EnclosingMethod_attribute a) {
try {
return getJavaName(a.getClassName(constant_pool));
} catch (ConstantPoolException e) {
return report(e);
}
}
private String getMethodName(EnclosingMethod_attribute a) {
try {
return a.getMethodName(constant_pool);
} catch (ConstantPoolException e) {
return report(e);
}
}
public Void visitExceptions(Exceptions_attribute attr, Void ignore) {
println("Exceptions:");
indent(+1);
print("throws ");
for (int i = 0; i < attr.number_of_exceptions; i++) {
if (i > 0)
print(", ");
print(getJavaException(attr, i));
}
println();
indent(-1);
return null;
}
private String getJavaException(Exceptions_attribute attr, int index) {
try {
return getJavaName(attr.getException(index, constant_pool));
} catch (ConstantPoolException e) {
return report(e);
}
}
public Void visitInnerClasses(InnerClasses_attribute attr, Void ignore) {
boolean first = true;
if (options.compat) {
writeInnerClassHeader();
first = false;
}
for (int i = 0 ; i < attr.classes.length; i++) {
InnerClasses_attribute.Info info = attr.classes[i];
//access
AccessFlags access_flags = info.inner_class_access_flags;
if (options.compat) {
// BUG 6622215: javap ignores certain relevant access flags
access_flags = access_flags.ignore(ACC_STATIC | ACC_PROTECTED | ACC_PRIVATE | ACC_INTERFACE | ACC_SYNTHETIC | ACC_ENUM);
// BUG 6622232: javap gets whitespace confused
print(" ");
}
if (options.checkAccess(access_flags)) {
if (first) {
writeInnerClassHeader();
first = false;
}
print(" ");
for (String name: access_flags.getInnerClassModifiers())
print(name + " ");
if (info.inner_name_index!=0) {
print("#" + info.inner_name_index + "= ");
}
print("#" + info.inner_class_info_index);
if (info.outer_class_info_index != 0) {
print(" of #" + info.outer_class_info_index);
}
print("; //");
if (info.inner_name_index != 0) {
print(getInnerName(constant_pool, info) + "=");
}
constantWriter.write(info.inner_class_info_index);
if (info.outer_class_info_index != 0) {
print(" of ");
constantWriter.write(info.outer_class_info_index);
}
println();
}
}
if (!first)
indent(-1);
return null;
}
String getInnerName(ConstantPool constant_pool, InnerClasses_attribute.Info info) {
try {
return info.getInnerName(constant_pool);
} catch (ConstantPoolException e) {
return report(e);
}
}
private void writeInnerClassHeader() {
if (options.compat) // BUG 6622216: javap names some attributes incorrectly
print("InnerClass");
else
print("InnerClasses");
println(":");
indent(+1);
}
public Void visitLineNumberTable(LineNumberTable_attribute attr, Void ignore) {
println("LineNumberTable:");
indent(+1);
for (LineNumberTable_attribute.Entry entry: attr.line_number_table) {
println("line " + entry.line_number + ": " + entry.start_pc);
}
indent(-1);
return null;
}
public Void visitLocalVariableTable(LocalVariableTable_attribute attr, Void ignore) {
println("LocalVariableTable:");
indent(+1);
println("Start Length Slot Name Signature");
for (LocalVariableTable_attribute.Entry entry : attr.local_variable_table) {
println(String.format("%5d %7d %5d %5s %s",
entry.start_pc, entry.length, entry.index,
constantWriter.stringValue(entry.name_index),
constantWriter.stringValue(entry.descriptor_index)));
}
indent(-1);
return null;
}
public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, Void ignore) {
println("LocalVariableTypeTable:");
indent(+1);
println("Start Length Slot Name Signature");
for (LocalVariableTypeTable_attribute.Entry entry : attr.local_variable_table) {
println(String.format("%5d %7d %5d %5s %s",
entry.start_pc, entry.length, entry.index,
constantWriter.stringValue(entry.name_index),
constantWriter.stringValue(entry.signature_index)));
}
indent(-1);
return null;
}
private static final String format = "%-31s%s";
public Void visitMethodParameters(MethodParameters_attribute attr,
Void ignore) {
final String header = String.format(format, "Name", "Flags");
println("MethodParameters:");
indent(+1);
println(header);
for (MethodParameters_attribute.Entry entry :
attr.method_parameter_table) {
String namestr =
entry.name_index != 0 ?
constantWriter.stringValue(entry.name_index) : "<no name>";
String flagstr =
(0 != (entry.flags & ACC_FINAL) ? "final " : "") +
(0 != (entry.flags & ACC_MANDATED) ? "mandated " : "") +
(0 != (entry.flags & ACC_SYNTHETIC) ? "synthetic" : "");
println(String.format(format, namestr, flagstr));
}
indent(-1);
return null;
}
public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, Void ignore) {
println("RuntimeVisibleAnnotations:");
indent(+1);
for (int i = 0; i < attr.annotations.length; i++) {
print(i + ": ");
annotationWriter.write(attr.annotations[i]);
println();
}
indent(-1);
return null;
}
public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, Void ignore) {
println("RuntimeInvisibleAnnotations:");
indent(+1);
for (int i = 0; i < attr.annotations.length; i++) {
print(i + ": ");
annotationWriter.write(attr.annotations[i]);
println();
}
indent(-1);
return null;
}
public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, Void ignore) {
println("RuntimeVisibleTypeAnnotations:");
indent(+1);
for (int i = 0; i < attr.annotations.length; i++) {
print(i + ": ");
annotationWriter.write(attr.annotations[i]);
println();
}
indent(-1);
return null;
}
public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, Void ignore) {
println("RuntimeInvisibleTypeAnnotations:");
indent(+1);
for (int i = 0; i < attr.annotations.length; i++) {
print(i + ": ");
annotationWriter.write(attr.annotations[i]);
println();
}
indent(-1);
return null;
}
public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, Void ignore) {
println("RuntimeVisibleParameterAnnotations:");
indent(+1);
for (int param = 0; param < attr.parameter_annotations.length; param++) {
println("parameter " + param + ": ");
indent(+1);
for (int i = 0; i < attr.parameter_annotations[param].length; i++) {
print(i + ": ");
annotationWriter.write(attr.parameter_annotations[param][i]);
println();
}
indent(-1);
}
indent(-1);
return null;
}
public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, Void ignore) {
println("RuntimeInvisibleParameterAnnotations:");
indent(+1);
for (int param = 0; param < attr.parameter_annotations.length; param++) {
println(param + ": ");
indent(+1);
for (int i = 0; i < attr.parameter_annotations[param].length; i++) {
print(i + ": ");
annotationWriter.write(attr.parameter_annotations[param][i]);
println();
}
indent(-1);
}
indent(-1);
return null;
}
public Void visitSignature(Signature_attribute attr, Void ignore) {
print("Signature: #" + attr.signature_index);
tab();
println("// " + getSignature(attr));
return null;
}
String getSignature(Signature_attribute info) {
try {
return info.getSignature(constant_pool);
} catch (ConstantPoolException e) {
return report(e);
}
}
public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, Void ignore) {
println("SourceDebugExtension:");
indent(+1);
for (String s: attr.getValue().split("[\r\n]+")) {
println(s);
}
indent(-1);
return null;
}
public Void visitSourceFile(SourceFile_attribute attr, Void ignore) {
println("SourceFile: \"" + getSourceFile(attr) + "\"");
return null;
}
private String getSourceFile(SourceFile_attribute attr) {
try {
return attr.getSourceFile(constant_pool);
} catch (ConstantPoolException e) {
return report(e);
}
}
public Void visitSourceID(SourceID_attribute attr, Void ignore) {
constantWriter.write(attr.sourceID_index);
return null;
}
public Void visitStackMap(StackMap_attribute attr, Void ignore) {
println("StackMap: number_of_entries = " + attr.number_of_entries);
indent(+1);
StackMapTableWriter w = new StackMapTableWriter();
for (StackMapTable_attribute.stack_map_frame entry : attr.entries) {
w.write(entry);
}
println();
indent(-1);
return null;
}
public Void visitStackMapTable(StackMapTable_attribute attr, Void ignore) {
println("StackMapTable: number_of_entries = " + attr.number_of_entries);
indent(+1);
StackMapTableWriter w = new StackMapTableWriter();
for (StackMapTable_attribute.stack_map_frame entry : attr.entries) {
w.write(entry);
}
println();
indent(-1);
return null;
}
class StackMapTableWriter // also handles CLDC StackMap attributes
implements StackMapTable_attribute.stack_map_frame.Visitor<Void,Void> {
public void write(StackMapTable_attribute.stack_map_frame frame) {
frame.accept(this, null);
}
public Void visit_same_frame(StackMapTable_attribute.same_frame frame, Void p) {
printHeader(frame);
println(" /* same */");
return null;
}
public Void visit_same_locals_1_stack_item_frame(StackMapTable_attribute.same_locals_1_stack_item_frame frame, Void p) {
printHeader(frame);
println(" /* same_locals_1_stack_item */");
indent(+1);
printMap("stack", frame.stack);
indent(-1);
return null;
}
public Void visit_same_locals_1_stack_item_frame_extended(StackMapTable_attribute.same_locals_1_stack_item_frame_extended frame, Void p) {
printHeader(frame);
println(" /* same_locals_1_stack_item_frame_extended */");
indent(+1);
println("offset_delta = " + frame.offset_delta);
printMap("stack", frame.stack);
indent(-1);
return null;
}
public Void visit_chop_frame(StackMapTable_attribute.chop_frame frame, Void p) {
printHeader(frame);
println(" /* chop */");
indent(+1);
println("offset_delta = " + frame.offset_delta);
indent(-1);
return null;
}
public Void visit_same_frame_extended(StackMapTable_attribute.same_frame_extended frame, Void p) {
printHeader(frame);
println(" /* same_frame_extended */");
indent(+1);
println("offset_delta = " + frame.offset_delta);
indent(-1);
return null;
}
public Void visit_append_frame(StackMapTable_attribute.append_frame frame, Void p) {
printHeader(frame);
println(" /* append */");
indent(+1);
println("offset_delta = " + frame.offset_delta);
printMap("locals", frame.locals);
return null;
}
public Void visit_full_frame(StackMapTable_attribute.full_frame frame, Void p) {
printHeader(frame);
if (frame instanceof StackMap_attribute.stack_map_frame) {
indent(+1);
println(" offset = " + frame.offset_delta);
} else {
println(" /* full_frame */");
indent(+1);
println("offset_delta = " + frame.offset_delta);
}
printMap("locals", frame.locals);
printMap("stack", frame.stack);
indent(-1);
return null;
}
void printHeader(StackMapTable_attribute.stack_map_frame frame) {
print(" frame_type = " + frame.frame_type);
}
void printMap(String name, StackMapTable_attribute.verification_type_info[] map) {
print(name + " = [");
for (int i = 0; i < map.length; i++) {
StackMapTable_attribute.verification_type_info info = map[i];
int tag = info.tag;
switch (tag) {
case StackMapTable_attribute.verification_type_info.ITEM_Object:
print(" ");
constantWriter.write(((StackMapTable_attribute.Object_variable_info) info).cpool_index);
break;
case StackMapTable_attribute.verification_type_info.ITEM_Uninitialized:
print(" " + mapTypeName(tag));
print(" " + ((StackMapTable_attribute.Uninitialized_variable_info) info).offset);
break;
default:
print(" " + mapTypeName(tag));
}
print(i == (map.length - 1) ? " " : ",");
}
println("]");
}
String mapTypeName(int tag) {
switch (tag) {
case StackMapTable_attribute.verification_type_info.ITEM_Top:
return "top";
case StackMapTable_attribute.verification_type_info.ITEM_Integer:
return "int";
case StackMapTable_attribute.verification_type_info.ITEM_Float:
return "float";
case StackMapTable_attribute.verification_type_info.ITEM_Long:
return "long";
case StackMapTable_attribute.verification_type_info.ITEM_Double:
return "double";
case StackMapTable_attribute.verification_type_info.ITEM_Null:
return "null";
case StackMapTable_attribute.verification_type_info.ITEM_UninitializedThis:
return "this";
case StackMapTable_attribute.verification_type_info.ITEM_Object:
return "CP";
case StackMapTable_attribute.verification_type_info.ITEM_Uninitialized:
return "uninitialized";
default:
report("unrecognized verification_type_info tag: " + tag);
return "[tag:" + tag + "]";
}
}
}
public Void visitSynthetic(Synthetic_attribute attr, Void ignore) {
println("Synthetic: true");
return null;
}
static String getJavaName(String name) {
return name.replace('/', '.');
}
String toHex(byte b, int w) {
if (options.compat) // BUG 6622260: javap prints negative bytes incorrectly in hex
return toHex((int) b, w);
else
return toHex(b & 0xff, w);
}
static String toHex(int i) {
return Integer.toString(i, 16).toUpperCase();
}
static String toHex(int i, int w) {
String s = Integer.toHexString(i).toUpperCase();
while (s.length() < w)
s = "0" + s;
return s.toUpperCase();
}
private AnnotationWriter annotationWriter;
private CodeWriter codeWriter;
private ConstantWriter constantWriter;
private Options options;
private ConstantPool constant_pool;
private Object owner;
}
Other Java examples (source code examples)Here is a short list of links related to this Java AttributeWriter.java source code file: |
The search page
Other Java source code examples at this package level
Click here to learn more about this project
