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.name + " " + 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 } |
|