1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 package com.sun.org.apache.bcel.internal.classfile;
6
7 /* ====================================================================
8 * The Apache Software License, Version 1.1
9 *
10 * Copyright (c) 2001 The Apache Software Foundation. All rights
11 * reserved.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 *
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 *
20 * 2. Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in
22 * the documentation and/or other materials provided with the
23 * distribution.
24 *
25 * 3. The end-user documentation included with the redistribution,
26 * if any, must include the following acknowledgment:
27 * "This product includes software developed by the
28 * Apache Software Foundation (http://www.apache.org/)."
29 * Alternately, this acknowledgment may appear in the software itself,
30 * if and wherever such third-party acknowledgments normally appear.
31 *
32 * 4. The names "Apache" and "Apache Software Foundation" and
33 * "Apache BCEL" must not be used to endorse or promote products
34 * derived from this software without prior written permission. For
35 * written permission, please contact apache@apache.org.
36 *
37 * 5. Products derived from this software may not be called "Apache",
38 * "Apache BCEL", nor may "Apache" appear in their name, without
39 * prior written permission of the Apache Software Foundation.
40 *
41 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
42 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
43 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
44 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
45 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
46 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
47 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
48 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
49 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
50 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
51 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * SUCH DAMAGE.
53 * ====================================================================
54 *
55 * This software consists of voluntary contributions made by many
56 * individuals on behalf of the Apache Software Foundation. For more
57 * information on the Apache Software Foundation, please see
58 * <http://www.apache.org/>.
59 */
60
61 import com.sun.org.apache.bcel.internal.Constants;
62 import java.io.*;
63
64 /**
65 * This class represents the constant pool, i.e., a table of constants, of
66 * a parsed classfile. It may contain null references, due to the JVM
67 * specification that skips an entry after an 8-byte constant (double,
68 * long) entry. Those interested in generating constant pools
69 * programatically should see <a href="../generic/ConstantPoolGen.html">
70 * ConstantPoolGen</a>.
71
72 * @see Constant
73 * @see com.sun.org.apache.bcel.internal.generic.ConstantPoolGen
74 * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
75 */
76 public class ConstantPool implements Cloneable, Node, Serializable {
77 private int constant_pool_count;
78 private Constant[] constant_pool;
79
80 /**
81 * @param constant_pool Array of constants
82 */
83 public ConstantPool(Constant[] constant_pool)
84 {
85 setConstantPool(constant_pool);
86 }
87
88 /**
89 * Read constants from given file stream.
90 *
91 * @param file Input stream
92 * @throws IOException
93 * @throws ClassFormatException
94 */
95 ConstantPool(DataInputStream file) throws IOException, ClassFormatException
96 {
97 byte tag;
98
99 constant_pool_count = file.readUnsignedShort();
100 constant_pool = new Constant[constant_pool_count];
101
102 /* constant_pool[0] is unused by the compiler and may be used freely
103 * by the implementation.
104 */
105 for(int i=1; i < constant_pool_count; i++) {
106 constant_pool[i] = Constant.readConstant(file);
107
108 /* Quote from the JVM specification:
109 * "All eight byte constants take up two spots in the constant pool.
110 * If this is the n'th byte in the constant pool, then the next item
111 * will be numbered n+2"
112 *
113 * Thus we have to increment the index counter.
114 */
115 tag = constant_pool[i].getTag();
116 if((tag == Constants.CONSTANT_Double) || (tag == Constants.CONSTANT_Long))
117 i++;
118 }
119 }
120
121 /**
122 * Called by objects that are traversing the nodes of the tree implicitely
123 * defined by the contents of a Java class. I.e., the hierarchy of methods,
124 * fields, attributes, etc. spawns a tree of objects.
125 *
126 * @param v Visitor object
127 */
128 public void accept(Visitor v) {
129 v.visitConstantPool(this);
130 }
131
132 /**
133 * Resolve constant to a string representation.
134 *
135 * @param constant Constant to be printed
136 * @return String representation
137 */
138 public String constantToString(Constant c)
139 throws ClassFormatException
140 {
141 String str;
142 int i;
143 byte tag = c.getTag();
144
145 switch(tag) {
146 case Constants.CONSTANT_Class:
147 i = ((ConstantClass)c).getNameIndex();
148 c = getConstant(i, Constants.CONSTANT_Utf8);
149 str = Utility.compactClassName(((ConstantUtf8)c).getBytes(), false);
150 break;
151
152 case Constants.CONSTANT_String:
153 i = ((ConstantString)c).getStringIndex();
154 c = getConstant(i, Constants.CONSTANT_Utf8);
155 str = "\"" + escape(((ConstantUtf8)c).getBytes()) + "\"";
156 break;
157
158 case Constants.CONSTANT_Utf8: str = ((ConstantUtf8)c).getBytes(); break;
159 case Constants.CONSTANT_Double: str = "" + ((ConstantDouble)c).getBytes(); break;
160 case Constants.CONSTANT_Float: str = "" + ((ConstantFloat)c).getBytes(); break;
161 case Constants.CONSTANT_Long: str = "" + ((ConstantLong)c).getBytes(); break;
162 case Constants.CONSTANT_Integer: str = "" + ((ConstantInteger)c).getBytes(); break;
163
164 case Constants.CONSTANT_NameAndType:
165 str = (constantToString(((ConstantNameAndType)c).getNameIndex(),
166 Constants.CONSTANT_Utf8) + " " +
167 constantToString(((ConstantNameAndType)c).getSignatureIndex(),
168 Constants.CONSTANT_Utf8));
169 break;
170
171 case Constants.CONSTANT_InterfaceMethodref: case Constants.CONSTANT_Methodref:
172 case Constants.CONSTANT_Fieldref:
173 str = (constantToString(((ConstantCP)c).getClassIndex(),
174 Constants.CONSTANT_Class) + "." +
175 constantToString(((ConstantCP)c).getNameAndTypeIndex(),
176 Constants.CONSTANT_NameAndType));
177 break;
178
179 default: // Never reached
180 throw new RuntimeException("Unknown constant type " + tag);
181 }
182
183 return str;
184 }
185
186 private static final String escape(String str) {
187 int len = str.length();
188 StringBuffer buf = new StringBuffer(len + 5);
189 char[] ch = str.toCharArray();
190
191 for(int i=0; i < len; i++) {
192 switch(ch[i]) {
193 case '\n' : buf.append("\\n"); break;
194 case '\r' : buf.append("\\r"); break;
195 case '\t' : buf.append("\\t"); break;
196 case '\b' : buf.append("\\b"); break;
197 case '"' : buf.append("\\\""); break;
198 default: buf.append(ch[i]);
199 }
200 }
201
202 return buf.toString();
203 }
204
205
206 /**
207 * Retrieve constant at `index' from constant pool and resolve it to
208 * a string representation.
209 *
210 * @param index of constant in constant pool
211 * @param tag expected type
212 * @return String representation
213 */
214 public String constantToString(int index, byte tag)
215 throws ClassFormatException
216 {
217 Constant c = getConstant(index, tag);
218 return constantToString(c);
219 }
220
221 /**
222 * Dump constant pool to file stream in binary format.
223 *
224 * @param file Output file stream
225 * @throws IOException
226 */
227 public void dump(DataOutputStream file) throws IOException
228 {
229 file.writeShort(constant_pool_count);
230
231 for(int i=1; i < constant_pool_count; i++)
232 if(constant_pool[i] != null)
233 constant_pool[i].dump(file);
234 }
235
236 /**
237 * Get constant from constant pool.
238 *
239 * @param index Index in constant pool
240 * @return Constant value
241 * @see Constant
242 */
243 public Constant getConstant(int index) {
244 if (index >= constant_pool.length || index < 0)
245 throw new ClassFormatException("Invalid constant pool reference: " +
246 index + ". Constant pool size is: " +
247 constant_pool.length);
248 return constant_pool[index];
249 }
250
251 /**
252 * Get constant from constant pool and check whether it has the
253 * expected type.
254 *
255 * @param index Index in constant pool
256 * @param tag Tag of expected constant, i.e., its type
257 * @return Constant value
258 * @see Constant
259 * @throws ClassFormatException
260 */
261 public Constant getConstant(int index, byte tag)
262 throws ClassFormatException
263 {
264 Constant c;
265
266 c = getConstant(index);
267
268 if(c == null)
269 throw new ClassFormatException("Constant pool at index " + index + " is null.");
270
271 if(c.getTag() == tag)
272 return c;
273 else
274 throw new ClassFormatException("Expected class `" + Constants.CONSTANT_NAMES[tag] +
275 "' at index " + index + " and got " + c);
276 }
277
278 /**
279 * @return Array of constants.
280 * @see Constant
281 */
282 public Constant[] getConstantPool() { return constant_pool; }
283 /**
284 * Get string from constant pool and bypass the indirection of
285 * `ConstantClass' and `ConstantString' objects. I.e. these classes have
286 * an index field that points to another entry of the constant pool of
287 * type `ConstantUtf8' which contains the real data.
288 *
289 * @param index Index in constant pool
290 * @param tag Tag of expected constant, either ConstantClass or ConstantString
291 * @return Contents of string reference
292 * @see ConstantClass
293 * @see ConstantString
294 * @throws ClassFormatException
295 */
296 public String getConstantString(int index, byte tag)
297 throws ClassFormatException
298 {
299 Constant c;
300 int i;
301
302 c = getConstant(index, tag);
303
304 /* This switch() is not that elegant, since the two classes have the
305 * same contents, they just differ in the name of the index
306 * field variable.
307 * But we want to stick to the JVM naming conventions closely though
308 * we could have solved these more elegantly by using the same
309 * variable name or by subclassing.
310 */
311 switch(tag) {
312 case Constants.CONSTANT_Class: i = ((ConstantClass)c).getNameIndex(); break;
313 case Constants.CONSTANT_String: i = ((ConstantString)c).getStringIndex(); break;
314 default:
315 throw new RuntimeException("getConstantString called with illegal tag " + tag);
316 }
317
318 // Finally get the string from the constant pool
319 c = getConstant(i, Constants.CONSTANT_Utf8);
320 return ((ConstantUtf8)c).getBytes();
321 }
322 /**
323 * @return Length of constant pool.
324 */
325 public int getLength()
326 {
327 return constant_pool_count;
328 }
329
330 /**
331 * @param constant Constant to set
332 */
333 public void setConstant(int index, Constant constant) {
334 constant_pool[index] = constant;
335 }
336
337 /**
338 * @param constant_pool
339 */
340 public void setConstantPool(Constant[] constant_pool) {
341 this.constant_pool = constant_pool;
342 constant_pool_count = (constant_pool == null)? 0 : constant_pool.length;
343 }
344 /**
345 * @return String representation.
346 */
347 public String toString() {
348 StringBuffer buf = new StringBuffer();
349
350 for(int i=1; i < constant_pool_count; i++)
351 buf.append(i + ")" + constant_pool[i] + "\n");
352
353 return buf.toString();
354 }
355
356 /**
357 * @return deep copy of this constant pool
358 */
359 public ConstantPool copy() {
360 ConstantPool c = null;
361
362 try {
363 c = (ConstantPool)clone();
364 } catch(CloneNotSupportedException e) {}
365
366 c.constant_pool = new Constant[constant_pool_count];
367
368 for(int i=1; i < constant_pool_count; i++) {
369 if(constant_pool[i] != null)
370 c.constant_pool[i] = constant_pool[i].copy();
371 }
372
373 return c;
374 }
375 }