1 /*
2 * Copyright (c) 2007, 2014, 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.ClassFile;
29 import com.sun.tools.classfile.ConstantPool;
30 import com.sun.tools.classfile.ConstantPoolException;
31
32 import static com.sun.tools.classfile.ConstantPool.*;
33
34 /*
35 * Write a constant pool entry.
36 *
37 * <p><b>This is NOT part of any supported API.
38 * If you write code that depends on this, you do so at your own risk.
39 * This code and its internal interfaces are subject to change or
40 * deletion without notice.</b>
41 */
42 public class ConstantWriter extends BasicWriter {
43 public static ConstantWriter instance(Context context) {
44 ConstantWriter instance = context.get(ConstantWriter.class);
45 if (instance == null)
46 instance = new ConstantWriter(context);
47 return instance;
48 }
49
50 protected ConstantWriter(Context context) {
51 super(context);
52 context.put(ConstantWriter.class, this);
53 classWriter = ClassWriter.instance(context);
54 options = Options.instance(context);
55 }
56
57 protected void writeConstantPool() {
58 ConstantPool constant_pool = classWriter.getClassFile().constant_pool;
59 writeConstantPool(constant_pool);
60 }
61
62 protected void writeConstantPool(ConstantPool constant_pool) {
63 ConstantPool.Visitor<Integer, Void> v = new ConstantPool.Visitor<Integer,Void>() {
64 public Integer visitClass(CONSTANT_Class_info info, Void p) {
65 print("#" + info.name_index);
66 tab();
67 println("// " + stringValue(info));
68 return 1;
69 }
70
71 public Integer visitDouble(CONSTANT_Double_info info, Void p) {
72 println(stringValue(info));
73 return 2;
74 }
75
76 public Integer visitFieldref(CONSTANT_Fieldref_info info, Void p) {
77 print("#" + info.class_index + ".#" + info.name_and_type_index);
78 tab();
79 println("// " + stringValue(info));
80 return 1;
81 }
82
83 public Integer visitFloat(CONSTANT_Float_info info, Void p) {
84 println(stringValue(info));
85 return 1;
86 }
87
88 public Integer visitInteger(CONSTANT_Integer_info info, Void p) {
89 println(stringValue(info));
90 return 1;
91 }
92
93 public Integer visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Void p) {
94 print("#" + info.class_index + ".#" + info.name_and_type_index);
95 tab();
96 println("// " + stringValue(info));
97 return 1;
98 }
99
100 public Integer visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Void p) {
101 print("#" + info.bootstrap_method_attr_index + ":#" + info.name_and_type_index);
102 tab();
103 println("// " + stringValue(info));
104 return 1;
105 }
106
107 public Integer visitLong(CONSTANT_Long_info info, Void p) {
108 println(stringValue(info));
109 return 2;
110 }
111
112 public Integer visitNameAndType(CONSTANT_NameAndType_info info, Void p) {
113 print("#" + info.name_index + ":#" + info.type_index);
114 tab();
115 println("// " + stringValue(info));
116 return 1;
117 }
118
119 public Integer visitMethodref(CONSTANT_Methodref_info info, Void p) {
120 print("#" + info.class_index + ".#" + info.name_and_type_index);
121 tab();
122 println("// " + stringValue(info));
123 return 1;
124 }
125
126 public Integer visitMethodHandle(CONSTANT_MethodHandle_info info, Void p) {
127 print(info.reference_kind.tag + ":#" + info.reference_index);
128 tab();
129 println("// " + stringValue(info));
130 return 1;
131 }
132
133 public Integer visitMethodType(CONSTANT_MethodType_info info, Void p) {
134 print("#" + info.descriptor_index);
135 tab();
136 println("// " + stringValue(info));
137 return 1;
138 }
139
140 public Integer visitString(CONSTANT_String_info info, Void p) {
141 print("#" + info.string_index);
142 tab();
143 println("// " + stringValue(info));
144 return 1;
145 }
146
147 public Integer visitUtf8(CONSTANT_Utf8_info info, Void p) {
148 println(stringValue(info));
149 return 1;
150 }
151
152 };
153 println("Constant pool:");
154 indent(+1);
155 int width = String.valueOf(constant_pool.size()).length() + 1;
156 int cpx = 1;
157 while (cpx < constant_pool.size()) {
158 print(String.format("%" + width + "s", ("#" + cpx)));
159 try {
160 CPInfo cpInfo = constant_pool.get(cpx);
161 print(String.format(" = %-18s ", cpTagName(cpInfo)));
162 cpx += cpInfo.accept(v, null);
163 } catch (ConstantPool.InvalidIndex ex) {
164 // should not happen
165 }
166 }
167 indent(-1);
168 }
169
170 protected void write(int cpx) {
171 ClassFile classFile = classWriter.getClassFile();
172 if (cpx == 0) {
173 print("#0");
174 return;
175 }
176
177 CPInfo cpInfo;
178 try {
179 cpInfo = classFile.constant_pool.get(cpx);
180 } catch (ConstantPoolException e) {
181 print("#" + cpx);
182 return;
183 }
184
185 int tag = cpInfo.getTag();
186 switch (tag) {
187 case CONSTANT_Methodref:
188 case CONSTANT_InterfaceMethodref:
189 case CONSTANT_Fieldref:
190 // simplify references within this class
191 CPRefInfo ref = (CPRefInfo) cpInfo;
192 try {
193 if (ref.class_index == classFile.this_class)
194 cpInfo = classFile.constant_pool.get(ref.name_and_type_index);
195 } catch (ConstantPool.InvalidIndex e) {
196 // ignore, for now
197 }
198 }
199 print(tagName(tag) + " " + stringValue(cpInfo));
200 }
201
202 String cpTagName(CPInfo cpInfo) {
203 String n = cpInfo.getClass().getSimpleName();
204 return n.replace("CONSTANT_", "").replace("_info", "");
205 }
206
207 String tagName(int tag) {
208 switch (tag) {
209 case CONSTANT_Utf8:
210 return "Utf8";
211 case CONSTANT_Integer:
212 return "int";
213 case CONSTANT_Float:
214 return "float";
215 case CONSTANT_Long:
216 return "long";
217 case CONSTANT_Double:
218 return "double";
219 case CONSTANT_Class:
220 return "class";
221 case CONSTANT_String:
222 return "String";
223 case CONSTANT_Fieldref:
224 return "Field";
225 case CONSTANT_MethodHandle:
226 return "MethodHandle";
227 case CONSTANT_MethodType:
228 return "MethodType";
229 case CONSTANT_Methodref:
230 return "Method";
231 case CONSTANT_InterfaceMethodref:
232 return "InterfaceMethod";
233 case CONSTANT_InvokeDynamic:
234 return "InvokeDynamic";
235 case CONSTANT_NameAndType:
236 return "NameAndType";
237 default:
238 return "(unknown tag " + tag + ")";
239 }
240 }
241
242 String stringValue(int constant_pool_index) {
243 ClassFile classFile = classWriter.getClassFile();
244 try {
245 return stringValue(classFile.constant_pool.get(constant_pool_index));
246 } catch (ConstantPool.InvalidIndex e) {
247 return report(e);
248 }
249 }
250
251 String stringValue(CPInfo cpInfo) {
252 return stringValueVisitor.visit(cpInfo);
253 }
254
255 StringValueVisitor stringValueVisitor = new StringValueVisitor();
256
257 private class StringValueVisitor implements ConstantPool.Visitor<String, Void> {
258 public String visit(CPInfo info) {
259 return info.accept(this, null);
260 }
261
262 public String visitClass(CONSTANT_Class_info info, Void p) {
263 return getCheckedName(info);
264 }
265
266 String getCheckedName(CONSTANT_Class_info info) {
267 try {
268 return checkName(info.getName());
269 } catch (ConstantPoolException e) {
270 return report(e);
271 }
272 }
273
274 public String visitDouble(CONSTANT_Double_info info, Void p) {
275 return info.value + "d";
276 }
277
278 public String visitFieldref(CONSTANT_Fieldref_info info, Void p) {
279 return visitRef(info, p);
280 }
281
282 public String visitFloat(CONSTANT_Float_info info, Void p) {
283 return info.value + "f";
284 }
285
286 public String visitInteger(CONSTANT_Integer_info info, Void p) {
287 return String.valueOf(info.value);
288 }
289
290 public String visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, Void p) {
291 return visitRef(info, p);
292 }
293
294 public String visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, Void p) {
295 try {
296 String callee = stringValue(info.getNameAndTypeInfo());
297 return "#" + info.bootstrap_method_attr_index + ":" + callee;
298 } catch (ConstantPoolException e) {
299 return report(e);
300 }
301 }
302
303 public String visitLong(CONSTANT_Long_info info, Void p) {
304 return info.value + "l";
305 }
306
307 public String visitNameAndType(CONSTANT_NameAndType_info info, Void p) {
308 return getCheckedName(info) + ":" + getType(info);
309 }
310
311 String getCheckedName(CONSTANT_NameAndType_info info) {
312 try {
313 return checkName(info.getName());
314 } catch (ConstantPoolException e) {
315 return report(e);
316 }
317 }
318
319 String getType(CONSTANT_NameAndType_info info) {
320 try {
321 return info.getType();
322 } catch (ConstantPoolException e) {
323 return report(e);
324 }
325 }
326
327 public String visitMethodHandle(CONSTANT_MethodHandle_info info, Void p) {
328 try {
329 return info.reference_kind + " " + stringValue(info.getCPRefInfo());
330 } catch (ConstantPoolException e) {
331 return report(e);
332 }
333 }
334
335 public String visitMethodType(CONSTANT_MethodType_info info, Void p) {
336 try {
337 return info.getType();
338 } catch (ConstantPoolException e) {
339 return report(e);
340 }
341 }
342
343 public String visitMethodref(CONSTANT_Methodref_info info, Void p) {
344 return visitRef(info, p);
345 }
346
347 public String visitString(CONSTANT_String_info info, Void p) {
348 try {
349 ClassFile classFile = classWriter.getClassFile();
350 int string_index = info.string_index;
351 return stringValue(classFile.constant_pool.getUTF8Info(string_index));
352 } catch (ConstantPoolException e) {
353 return report(e);
354 }
355 }
356
357 public String visitUtf8(CONSTANT_Utf8_info info, Void p) {
358 String s = info.value;
359 StringBuilder sb = new StringBuilder();
360 for (int i = 0; i < s.length(); i++) {
361 char c = s.charAt(i);
362 switch (c) {
363 case '\t':
364 sb.append('\\').append('t');
365 break;
366 case '\n':
367 sb.append('\\').append('n');
368 break;
369 case '\r':
370 sb.append('\\').append('r');
371 break;
372 case '\b':
373 sb.append('\\').append('b');
374 break;
375 case '\f':
376 sb.append('\\').append('f');
377 break;
378 case '\"':
379 sb.append('\\').append('\"');
380 break;
381 case '\'':
382 sb.append('\\').append('\'');
383 break;
384 case '\\':
385 sb.append('\\').append('\\');
386 break;
387 default:
388 sb.append(c);
389 }
390 }
391 return sb.toString();
392 }
393
394 String visitRef(CPRefInfo info, Void p) {
395 String cn = getCheckedClassName(info);
396 String nat;
397 try {
398 nat = stringValue(info.getNameAndTypeInfo());
399 } catch (ConstantPoolException e) {
400 nat = report(e);
401 }
402 return cn + "." + nat;
403 }
404
405 String getCheckedClassName(CPRefInfo info) {
406 try {
407 return checkName(info.getClassName());
408 } catch (ConstantPoolException e) {
409 return report(e);
410 }
411 }
412 }
413
414 /* If name is a valid binary name, return it; otherwise quote it. */
415 private static String checkName(String name) {
416 if (name == null)
417 return "null";
418
419 int len = name.length();
420 if (len == 0)
421 return "\"\"";
422
423 int cc = '/';
424 int cp;
425 for (int k = 0; k < len; k += Character.charCount(cp)) {
426 cp = name.codePointAt(k);
427 if ((cc == '/' && !Character.isJavaIdentifierStart(cp))
428 || (cp != '/' && !Character.isJavaIdentifierPart(cp))) {
429 return "\"" + addEscapes(name) + "\"";
430 }
431 cc = cp;
432 }
433
434 return name;
435 }
436
437 /* If name requires escapes, put them in, so it can be a string body. */
438 private static String addEscapes(String name) {
439 String esc = "\\\"\n\t";
440 String rep = "\\\"nt";
441 StringBuilder buf = null;
442 int nextk = 0;
443 int len = name.length();
444 for (int k = 0; k < len; k++) {
445 char cp = name.charAt(k);
446 int n = esc.indexOf(cp);
447 if (n >= 0) {
448 if (buf == null)
449 buf = new StringBuilder(len * 2);
450 if (nextk < k)
451 buf.append(name, nextk, k);
452 buf.append('\\');
453 buf.append(rep.charAt(n));
454 nextk = k+1;
455 }
456 }
457 if (buf == null)
458 return name;
459 if (nextk < len)
460 buf.append(name, nextk, len);
461 return buf.toString();
462 }
463
464 private ClassWriter classWriter;
465 private Options options;
466 }