1 /*
2 * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.javap;
27
28 import com.sun.tools.classfile.Annotation;
29 import com.sun.tools.classfile.TypeAnnotation;
30 import com.sun.tools.classfile.Annotation.Annotation_element_value;
31 import com.sun.tools.classfile.Annotation.Array_element_value;
32 import com.sun.tools.classfile.Annotation.Class_element_value;
33 import com.sun.tools.classfile.Annotation.Enum_element_value;
34 import com.sun.tools.classfile.Annotation.Primitive_element_value;
35 import com.sun.tools.classfile.ConstantPool;
36 import com.sun.tools.classfile.ConstantPoolException;
37 import com.sun.tools.classfile.Descriptor;
38 import com.sun.tools.classfile.Descriptor.InvalidDescriptor;
39
40 /**
41 * A writer for writing annotations as text.
42 *
43 * <p><b>This is NOT part of any supported API.
44 * If you write code that depends on this, you do so at your own risk.
45 * This code and its internal interfaces are subject to change or
46 * deletion without notice.</b>
47 */
48 public class AnnotationWriter extends BasicWriter {
49 static AnnotationWriter instance(Context context) {
50 AnnotationWriter instance = context.get(AnnotationWriter.class);
51 if (instance == null)
52 instance = new AnnotationWriter(context);
53 return instance;
54 }
55
56 protected AnnotationWriter(Context context) {
57 super(context);
58 classWriter = ClassWriter.instance(context);
59 constantWriter = ConstantWriter.instance(context);
60 }
61
62 public void write(Annotation annot) {
63 write(annot, false);
64 }
65
66 public void write(Annotation annot, boolean resolveIndices) {
67 writeDescriptor(annot.type_index, resolveIndices);
68 boolean showParens = annot.num_element_value_pairs > 0 || !resolveIndices;
69 if (showParens)
70 print("(");
71 for (int i = 0; i < annot.num_element_value_pairs; i++) {
72 if (i > 0)
73 print(",");
74 write(annot.element_value_pairs[i], resolveIndices);
75 }
76 if (showParens)
77 print(")");
78 }
79
80 public void write(TypeAnnotation annot) {
81 write(annot, true, false);
82 }
83
84 public void write(TypeAnnotation annot, boolean showOffsets, boolean resolveIndices) {
85 write(annot.annotation, resolveIndices);
86 print(": ");
87 write(annot.position, showOffsets);
88 }
89
90 public void write(TypeAnnotation.Position pos, boolean showOffsets) {
91 print(pos.type);
92
93 switch (pos.type) {
94 // instanceof
95 case INSTANCEOF:
96 // new expression
97 case NEW:
98 // constructor/method reference receiver
99 case CONSTRUCTOR_REFERENCE:
100 case METHOD_REFERENCE:
101 if (showOffsets) {
102 print(", offset=");
103 print(pos.offset);
104 }
105 break;
106 // local variable
107 case LOCAL_VARIABLE:
108 // resource variable
109 case RESOURCE_VARIABLE:
110 if (pos.lvarOffset == null) {
111 print(", lvarOffset is Null!");
112 break;
113 }
114 print(", {");
115 for (int i = 0; i < pos.lvarOffset.length; ++i) {
116 if (i != 0) print("; ");
117 if (showOffsets) {
118 print("start_pc=");
119 print(pos.lvarOffset[i]);
120 }
121 print(", length=");
122 print(pos.lvarLength[i]);
123 print(", index=");
124 print(pos.lvarIndex[i]);
125 }
126 print("}");
127 break;
128 // exception parameter
129 case EXCEPTION_PARAMETER:
130 print(", exception_index=");
131 print(pos.exception_index);
132 break;
133 // method receiver
134 case METHOD_RECEIVER:
135 // Do nothing
136 break;
137 // type parameter
138 case CLASS_TYPE_PARAMETER:
139 case METHOD_TYPE_PARAMETER:
140 print(", param_index=");
141 print(pos.parameter_index);
142 break;
143 // type parameter bound
144 case CLASS_TYPE_PARAMETER_BOUND:
145 case METHOD_TYPE_PARAMETER_BOUND:
146 print(", param_index=");
147 print(pos.parameter_index);
148 print(", bound_index=");
149 print(pos.bound_index);
150 break;
151 // class extends or implements clause
152 case CLASS_EXTENDS:
153 print(", type_index=");
154 print(pos.type_index);
155 break;
156 // throws
157 case THROWS:
158 print(", type_index=");
159 print(pos.type_index);
160 break;
161 // method parameter
162 case METHOD_FORMAL_PARAMETER:
163 print(", param_index=");
164 print(pos.parameter_index);
165 break;
166 // type cast
167 case CAST:
168 // method/constructor/reference type argument
169 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
170 case METHOD_INVOCATION_TYPE_ARGUMENT:
171 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
172 case METHOD_REFERENCE_TYPE_ARGUMENT:
173 if (showOffsets) {
174 print(", offset=");
175 print(pos.offset);
176 }
177 print(", type_index=");
178 print(pos.type_index);
179 break;
180 // We don't need to worry about these
181 case METHOD_RETURN:
182 case FIELD:
183 break;
184 case UNKNOWN:
185 throw new AssertionError("AnnotationWriter: UNKNOWN target type should never occur!");
186 default:
187 throw new AssertionError("AnnotationWriter: Unknown target type for position: " + pos);
188 }
189
190 // Append location data for generics/arrays.
191 if (!pos.location.isEmpty()) {
192 print(", location=");
193 print(pos.location);
194 }
195 }
196
197 public void write(Annotation.element_value_pair pair) {
198 write(pair, false);
199 }
200
201 public void write(Annotation.element_value_pair pair, boolean resolveIndices) {
202 writeIndex(pair.element_name_index, resolveIndices);
203 print("=");
204 write(pair.value, resolveIndices);
205 }
206
207 public void write(Annotation.element_value value) {
208 write(value, false);
209 }
210
211 public void write(Annotation.element_value value, boolean resolveIndices) {
212 ev_writer.write(value, resolveIndices);
213 }
214
215 private void writeDescriptor(int index, boolean resolveIndices) {
216 if (resolveIndices) {
217 try {
218 ConstantPool constant_pool = classWriter.getClassFile().constant_pool;
219 Descriptor d = new Descriptor(index);
220 print(d.getFieldType(constant_pool));
221 return;
222 } catch (ConstantPoolException | InvalidDescriptor ignore) {
223 }
224 }
225
226 print("#" + index);
227 }
228
229 private void writeIndex(int index, boolean resolveIndices) {
230 if (resolveIndices) {
231 print(constantWriter.stringValue(index));
232 } else
233 print("#" + index);
234 }
235
236 element_value_Writer ev_writer = new element_value_Writer();
237
238 class element_value_Writer implements Annotation.element_value.Visitor<Void,Boolean> {
239 public void write(Annotation.element_value value, boolean resolveIndices) {
240 value.accept(this, resolveIndices);
241 }
242
243 public Void visitPrimitive(Primitive_element_value ev, Boolean resolveIndices) {
244 if (resolveIndices)
245 writeIndex(ev.const_value_index, resolveIndices);
246 else
247 print(((char) ev.tag) + "#" + ev.const_value_index);
248 return null;
249 }
250
251 public Void visitEnum(Enum_element_value ev, Boolean resolveIndices) {
252 if (resolveIndices) {
253 writeIndex(ev.type_name_index, resolveIndices);
254 print(".");
255 writeIndex(ev.const_name_index, resolveIndices);
256 } else
257 print(((char) ev.tag) + "#" + ev.type_name_index + ".#" + ev.const_name_index);
258 return null;
259 }
260
261 public Void visitClass(Class_element_value ev, Boolean resolveIndices) {
262 if (resolveIndices) {
263 writeIndex(ev.class_info_index, resolveIndices);
264 print(".class");
265 } else
266 print(((char) ev.tag) + "#" + ev.class_info_index);
267 return null;
268 }
269
270 public Void visitAnnotation(Annotation_element_value ev, Boolean resolveIndices) {
271 print((char) ev.tag);
272 AnnotationWriter.this.write(ev.annotation_value, resolveIndices);
273 return null;
274 }
275
276 public Void visitArray(Array_element_value ev, Boolean resolveIndices) {
277 print("[");
278 for (int i = 0; i < ev.num_values; i++) {
279 if (i > 0)
280 print(",");
281 write(ev.values[i], resolveIndices);
282 }
283 print("]");
284 return null;
285 }
286
287 }
288
289 private ClassWriter classWriter;
290 private ConstantWriter constantWriter;
291 }