Java > Open Source Codes > javassist > bytecode > ConstPool


1 /*
2  * Javassist, a Java-bytecode translator toolkit.
3  * Copyright (C) 1999-2005 Shigeru Chiba. All Rights Reserved.
4  *
5  * The contents of this file are subject to the Mozilla Public License Version
6  * 1.1 (the "License"); you may not use this file except in compliance with
7  * the License. Alternatively, the contents of this file may be used under
8  * the terms of the GNU Lesser General Public License Version 2.1 or later.
9  *
10  * Software distributed under the License is distributed on an "AS IS" basis,
11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12  * for the specific language governing rights and limitations under the
13  * License.
14  */
15
16 package javassist.bytecode;
17
18 import java.io.DataInputStream ;
19 import java.io.DataOutputStream ;
20 import java.io.ByteArrayOutputStream ;
21 import java.io.PrintWriter ;
22 import java.io.IOException ;
23 import java.util.Map ;
24 import java.util.HashMap ;
25 import javassist.CtClass;
26
27 /**
28  * Constant pool table.
29  */
30 public final class ConstPool {
31     LongVector items;
32     int numOfItems;
33     HashMap classes;
34     HashMap strings;
35     int thisClassInfo;
36
37     /**
38      * <code>CONSTANT_Class</code>
39      */
40     public static final int CONST_Class = ClassInfo.tag;
41
42     /**
43      * <code>CONSTANT_Fieldref</code>
44      */
45     public static final int CONST_Fieldref = FieldrefInfo.tag;
46
47     /**
48      * <code>CONSTANT_Methodref</code>
49      */
50     public static final int CONST_Methodref = MethodrefInfo.tag;
51
52     /**
53      * <code>CONSTANT_InterfaceMethodref</code>
54      */
55     public static final int CONST_InterfaceMethodref
56                                         = InterfaceMethodrefInfo.tag;
57
58     /**
59      * <code>CONSTANT_String</code>
60      */
61     public static final int CONST_String = StringInfo.tag;
62
63     /**
64      * <code>CONSTANT_Integer</code>
65      */
66     public static final int CONST_Integer = IntegerInfo.tag;
67
68     /**
69      * <code>CONSTANT_Float</code>
70      */
71     public static final int CONST_Float = FloatInfo.tag;
72
73     /**
74      * <code>CONSTANT_Long</code>
75      */
76     public static final int CONST_Long = LongInfo.tag;
77
78     /**
79      * <code>CONSTANT_Double</code>
80      */
81     public static final int CONST_Double = DoubleInfo.tag;
82
83     /**
84      * <code>CONSTANT_NameAndType</code>
85      */
86     public static final int CONST_NameAndType = NameAndTypeInfo.tag;
87
88     /**
89      * <code>CONSTANT_Utf8</code>
90      */
91     public static final int CONST_Utf8 = Utf8Info.tag;
92
93     /**
94      * Represents the class using this constant pool table.
95      */
96     public static final CtClass THIS = null;
97
98     /**
99      * Constructs a constant pool table.
100      *
101      * @param thisclass the name of the class using this constant
102      * pool table
103      */
104     public ConstPool(String thisclass) {
105         items = new LongVector();
106         numOfItems = 0;
107         addItem(null); // index 0 is reserved by the JVM.
108 classes = new HashMap ();
109         strings = new HashMap ();
110         thisClassInfo = addClassInfo(thisclass);
111     }
112
113     /**
114      * Constructs a constant pool table from the given byte stream.
115      *
116      * @param in byte stream.
117      */
118     public ConstPool(DataInputStream in) throws IOException {
119         classes = new HashMap ();
120         strings = new HashMap ();
121         thisClassInfo = 0;
122         /* read() initializes items and numOfItems, and do addItem(null).
123          */
124         read(in);
125     }
126
127     void prune() {
128         classes = new HashMap ();
129         strings = new HashMap ();
130     }
131
132     /**
133      * Returns the name of the class using this constant pool table.
134      */
135     public String getClassName() {
136         return getClassInfo(thisClassInfo);
137     }
138
139     /**
140      * Returns the index of <code>CONSTANT_Class_info</code> structure
141      * specifying the class using this constant pool table.
142      */
143     public int getThisClassInfo() {
144         return thisClassInfo;
145     }
146
147     void setThisClassInfo(int i) {
148         thisClassInfo = i;
149     }
150
151     ConstInfo getItem(int n) {
152         return (ConstInfo)items.elementAt(n);
153     }
154
155     /**
156      * Returns the <code>tag</code> field of the constant pool table
157      * entry at the given index.
158      */
159     public int getTag(int index) {
160         return getItem(index).getTag();
161     }
162
163     /**
164      * Reads <code>CONSTANT_Class_info</code> structure
165      * at the given index.
166      *
167      * @return a fully-qualified class or interface name specified
168      * by <code>name_index</code>.
169      */
170     public String getClassInfo(int index) {
171         ClassInfo c = (ClassInfo)getItem(index);
172         if (c == null)
173             return null;
174         else
175             return Descriptor.toJavaName(getUtf8Info(c.name));
176     }
177
178     /**
179      * Reads the <code>name_index</code> field of the
180      * <code>CONSTANT_NameAndType_info</code> structure
181      * at the given index.
182      */
183     public int getNameAndTypeName(int index) {
184         NameAndTypeInfo ntinfo = (NameAndTypeInfo)getItem(index);
185         return ntinfo.memberName;
186     }
187
188     /**
189      * Reads the <code>descriptor_index</code> field of the
190      * <code>CONSTANT_NameAndType_info</code> structure
191      * at the given index.
192      */
193     public int getNameAndTypeDescriptor(int index) {
194         NameAndTypeInfo ntinfo = (NameAndTypeInfo)getItem(index);
195         return ntinfo.typeDescriptor;
196     }
197
198     /**
199      * Reads the <code>class_index</code> field of the
200      * <code>CONSTANT_Fieldref_info</code> structure
201      * at the given index.
202      */
203     public int getFieldrefClass(int index) {
204         FieldrefInfo finfo = (FieldrefInfo)getItem(index);
205         return finfo.classIndex;
206     }
207
208     /**
209      * Reads the <code>class_index</code> field of the
210      * <code>CONSTANT_Fieldref_info</code> structure
211      * at the given index.
212      *
213      * @return the name of the class at that <code>class_index</code>.
214      */
215     public String getFieldrefClassName(int index) {
216         FieldrefInfo f = (FieldrefInfo)getItem(index);
217         if (f == null)
218             return null;
219         else
220             return getClassInfo(f.classIndex);
221     }
222
223     /**
224      * Reads the <code>name_and_type_index</code> field of the
225      * <code>CONSTANT_Fieldref_info</code> structure
226      * at the given index.
227      */
228     public int getFieldrefNameAndType(int index) {
229         FieldrefInfo finfo = (FieldrefInfo)getItem(index);
230         return finfo.nameAndTypeIndex;
231     }
232
233     /**
234      * Reads the <code>name_index</code> field of the
235      * <code>CONSTANT_NameAndType_info</code> structure
236      * indirectly specified by the given index.
237      *
238      * @param index an index to a <code>CONSTANT_Fieldref_info</code>.
239      * @return the name of the field.
240      */
241     public String getFieldrefName(int index) {
242         FieldrefInfo f = (FieldrefInfo)getItem(index);
243         if (f == null)
244             return null;
245         else {
246             NameAndTypeInfo n = (NameAndTypeInfo)getItem(f.nameAndTypeIndex);
247             if(n == null)
248                 return null;
249             else
250                 return getUtf8Info(n.memberName);
251         }
252     }
253
254     /**
255      * Reads the <code>descriptor_index</code> field of the
256      * <code>CONSTANT_NameAndType_info</code> structure
257      * indirectly specified by the given index.
258      *
259      * @param index an index to a <code>CONSTANT_Fieldref_info</code>.
260      * @return the type descriptor of the field.
261      */
262     public String getFieldrefType(int index) {
263         FieldrefInfo f = (FieldrefInfo)getItem(index);
264         if (f == null)
265             return null;
266         else {
267             NameAndTypeInfo n = (NameAndTypeInfo) getItem(f.nameAndTypeIndex);
268             if(n == null)
269                 return null;
270             else
271                 return getUtf8Info(n.typeDescriptor);
272         }
273     }
274
275     /**
276      * Reads the <code>class_index</code> field of the
277      * <code>CONSTANT_Methodref_info</code> structure
278      * at the given index.
279      */
280     public int getMethodrefClass(int index) {
281         MethodrefInfo minfo = (MethodrefInfo)getItem(index);
282         return minfo.classIndex;
283     }
284
285     /**
286      * Reads the <code>class_index</code> field of the
287      * <code>CONSTANT_Methodref_info</code> structure
288      * at the given index.
289      *
290      * @return the name of the class at that <code>class_index</code>.
291      */
292     public String getMethodrefClassName(int index) {
293         MethodrefInfo minfo = (MethodrefInfo)getItem(index);
294         if (minfo == null)
295             return null;
296         else
297             return getClassInfo(minfo.classIndex);
298     }
299
300     /**
301      * Reads the <code>name_and_type_index</code> field of the
302      * <code>CONSTANT_Methodref_info</code> structure
303      * at the given index.
304      */
305     public int getMethodrefNameAndType(int index) {
306         MethodrefInfo minfo = (MethodrefInfo)getItem(index);
307         return minfo.nameAndTypeIndex;
308     }
309
310     /**
311      * Reads the <code>name_index</code> field of the
312      * <code>CONSTANT_NameAndType_info</code> structure
313      * indirectly specified by the given index.
314      *
315      * @param index an index to a <code>CONSTANT_Methodref_info</code>.
316      * @return the name of the method.
317      */
318     public String getMethodrefName(int index) {
319         MethodrefInfo minfo = (MethodrefInfo)getItem(index);
320         if (minfo == null)
321             return null;
322         else {
323             NameAndTypeInfo n
324                 = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
325             if(n == null)
326                 return null;
327             else
328                 return getUtf8Info(n.memberName);
329         }
330     }
331
332     /**
333      * Reads the <code>descriptor_index</code> field of the
334      * <code>CONSTANT_NameAndType_info</code> structure
335      * indirectly specified by the given index.
336      *
337      * @param index an index to a <code>CONSTANT_Methodref_info</code>.
338      * @return the descriptor of the method.
339      */
340     public String getMethodrefType(int index) {
341         MethodrefInfo minfo = (MethodrefInfo)getItem(index);
342         if (minfo == null)
343             return null;
344         else {
345             NameAndTypeInfo n
346                 = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
347             if(n == null)
348                 return null;
349             else
350                 return getUtf8Info(n.typeDescriptor);
351         }
352     }
353
354     /**
355      * Reads the <code>class_index</code> field of the
356      * <code>CONSTANT_InterfaceMethodref_info</code> structure
357      * at the given index.
358      */
359     public int getInterfaceMethodrefClass(int index) {
360         InterfaceMethodrefInfo minfo
361             = (InterfaceMethodrefInfo)getItem(index);
362         return minfo.classIndex;
363     }
364
365     /**
366      * Reads the <code>class_index</code> field of the
367      * <code>CONSTANT_InterfaceMethodref_info</code> structure
368      * at the given index.
369      *
370      * @return the name of the class at that <code>class_index</code>.
371      */
372     public String getInterfaceMethodrefClassName(int index) {
373         InterfaceMethodrefInfo minfo
374             = (InterfaceMethodrefInfo)getItem(index);
375         return getClassInfo(minfo.classIndex);
376     }
377
378     /**
379      * Reads the <code>name_and_type_index</code> field of the
380      * <code>CONSTANT_InterfaceMethodref_info</code> structure
381      * at the given index.
382      */
383     public int getInterfaceMethodrefNameAndType(int index) {
384         InterfaceMethodrefInfo minfo
385             = (InterfaceMethodrefInfo)getItem(index);
386         return minfo.nameAndTypeIndex;
387     }
388
389     /**
390      * Reads the <code>name_index</code> field of the
391      * <code>CONSTANT_NameAndType_info</code> structure
392      * indirectly specified by the given index.
393      *
394      * @param index an index to
395      * a <code>CONSTANT_InterfaceMethodref_info</code>.
396      * @return the name of the method.
397      */
398     public String getInterfaceMethodrefName(int index) {
399         InterfaceMethodrefInfo minfo
400             = (InterfaceMethodrefInfo)getItem(index);
401         if (minfo == null)
402             return null;
403         else {
404             NameAndTypeInfo n
405                 = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
406             if(n == null)
407                 return null;
408             else
409                 return getUtf8Info(n.memberName);
410         }
411     }
412
413     /**
414      * Reads the <code>descriptor_index</code> field of the
415      * <code>CONSTANT_NameAndType_info</code> structure
416      * indirectly specified by the given index.
417      *
418      * @param index an index to
419      * a <code>CONSTANT_InterfaceMethodref_info</code>.
420      * @return the descriptor of the method.
421      */
422     public String getInterfaceMethodrefType(int index) {
423         InterfaceMethodrefInfo minfo
424             = (InterfaceMethodrefInfo)getItem(index);
425         if (minfo == null)
426             return null;
427         else {
428             NameAndTypeInfo n
429                 = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
430             if(n == null)
431                 return null;
432             else
433                 return getUtf8Info(n.typeDescriptor);
434         }
435     }
436     /**
437      * Reads <code>CONSTANT_Integer_info</code>, <code>_Float_info</code>,
438      * <code>_Long_info</code>, <code>_Double_info</code>, or
439      * <code>_String_info</code> structure.
440      * These are used with the LDC instruction.
441      *
442      * @return a <code>String</code> value or a wrapped primitive-type
443      * value.
444      */
445     public Object getLdcValue(int index) {
446         ConstInfo constInfo = this.getItem(index);
447         Object value = null;
448         if (constInfo instanceof StringInfo)
449             value = this.getStringInfo(index);
450         else if (constInfo instanceof FloatInfo)
451             value = new Float (getFloatInfo(index));
452         else if (constInfo instanceof IntegerInfo)
453             value = new Integer (getIntegerInfo(index));
454         else if (constInfo instanceof LongInfo)
455             value = new Long (getLongInfo(index));
456         else if (constInfo instanceof DoubleInfo)
457             value = new Double (getDoubleInfo(index));
458         else
459             value = null;
460
461         return value;
462     }
463
464     /**
465      * Reads <code>CONSTANT_Integer_info</code> structure
466      * at the given index.
467      *
468      * @return the value specified by this entry.
469      */
470     public int getIntegerInfo(int index) {
471         IntegerInfo i = (IntegerInfo)getItem(index);
472         return i.value;
473     }
474
475     /**
476      * Reads <code>CONSTANT_Float_info</code> structure
477      * at the given index.
478      *
479      * @return the value specified by this entry.
480      */
481     public float getFloatInfo(int index) {
482         FloatInfo i = (FloatInfo)getItem(index);
483         return i.value;
484     }
485
486     /**
487      * Reads <code>CONSTANT_Long_info</code> structure
488      * at the given index.
489      *
490      * @return the value specified by this entry.
491      */
492     public long getLongInfo(int index) {
493         LongInfo i = (LongInfo)getItem(index);
494         return i.value;
495     }
496
497     /**
498      * Reads <code>CONSTANT_Double_info</code> structure
499      * at the given index.
500      *
501      * @return the value specified by this entry.
502      */
503     public double getDoubleInfo(int index) {
504         DoubleInfo i = (DoubleInfo)getItem(index);
505         return i.value;
506     }
507
508     /**
509      * Reads <code>CONSTANT_String_info</code> structure
510      * at the given index.
511      *
512      * @return the string specified by <code>string_index</code>.
513      */
514     public String getStringInfo(int index) {
515         StringInfo si = (StringInfo)getItem(index);
516         return getUtf8Info(si.string);
517     }
518
519     /**
520      * Reads <code>CONSTANT_utf8_info</code> structure
521      * at the given index.
522      *
523      * @return the string specified by this entry.
524      */
525     public String getUtf8Info(int index) {
526         Utf8Info utf = (Utf8Info)getItem(index);
527         return utf.string;
528     }
529
530     /**
531      * Determines whether <code>CONSTANT_Methodref_info</code>
532      * structure at the given index represents the constructor
533      * of the given class.
534      *
535      * @return the <code>descriptor_index</code> specifying
536      * the type descriptor of the that constructor.
537      * If it is not that constructor,
538      * <code>isConstructor()</code> returns 0.
539      */
540     public int isConstructor(String classname, int index) {
541         return isMember(classname, MethodInfo.nameInit, index);
542     }
543
544     /**
545      * Determines whether <code>CONSTANT_Methodref_info</code>,
546      * <code>CONSTANT_Fieldref_info</code>, or
547      * <code>CONSTANT_InterfaceMethodref_info</code> structure
548      * at the given index represents the member with the specified
549      * name and declaring class.
550      *
551      * @param classname the class declaring the member
552      * @param membername the member name
553      * @param index the index into the constant pool table
554      *
555      * @return the <code>descriptor_index</code> specifying
556      * the type descriptor of that member.
557      * If it is not that member,
558      * <code>isMember()</code> returns 0.
559      */
560     public int isMember(String classname, String membername, int index) {
561         MemberrefInfo minfo = (MemberrefInfo)getItem(index);
562         if (getClassInfo(minfo.classIndex).equals(classname)) {
563             NameAndTypeInfo ntinfo
564                 = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
565             if (getUtf8Info(ntinfo.memberName).equals(membername))
566                 return ntinfo.typeDescriptor;
567         }
568
569         return 0; // false
570 }
571
572     private int addItem(ConstInfo info) {
573         items.addElement(info);
574         return numOfItems++;
575     }
576
577     /**
578      * Copies the n-th item in this ConstPool object into the destination
579      * ConstPool object.
580      * The class names that the item refers to are renamed according
581      * to the given map.
582      *
583      * @param n the <i>n</i>-th item
584      * @param dest destination constant pool table
585      * @param classnames the map or null.
586      * @return the index of the copied item into the destination ClassPool.
587      */
588     public int copy(int n, ConstPool dest, Map classnames) {
589         if (n == 0)
590             return 0;
591
592         ConstInfo info = getItem(n);
593         return info.copy(this, dest, classnames);
594     }
595
596     int addConstInfoPadding() {
597         return addItem(new ConstInfoPadding());
598     }
599
600     /**
601      * Adds a new <code>CONSTANT_Class_info</code> structure.
602      *
603      * <p>This also adds a <code>CONSTANT_Utf8_info</code> structure
604      * for storing the class name.
605      *
606      * @return the index of the added entry.
607      */
608     public int addClassInfo(CtClass c) {
609         if (c == THIS)
610             return thisClassInfo;
611         else if (!c.isArray())
612             return addClassInfo(c.getName());
613         else {
614             // an array type is recorded in the hashtable with
615 // the key "[L<classname>;" instead of "<classname>".
616 //
617 // note: toJvmName(toJvmName(c)) is equal to toJvmName(c).
618
619             return addClassInfo(Descriptor.toJvmName(c));
620         }
621     }
622
623     /**
624      * Adds a new <code>CONSTANT_Class_info</code> structure.
625      *
626      * <p>This also adds a <code>CONSTANT_Utf8_info</code> structure
627      * for storing the class name.
628      *
629      * @param qname a fully-qualified class name
630      * (or the JVM-internal representation of that name).
631      * @return the index of the added entry.
632      */
633     public int addClassInfo(String qname) {
634         ClassInfo info = (ClassInfo)classes.get(qname);
635         if (info != null)
636             return info.index;
637         else {
638             int utf8 = addUtf8Info(Descriptor.toJvmName(qname));
639             info = new ClassInfo(utf8, numOfItems);
640             classes.put(qname, info);
641             return addItem(info);
642         }
643     }
644
645     /**
646      * Adds a new <code>CONSTANT_NameAndType_info</code> structure.
647      *
648      * <p>This also adds <code>CONSTANT_Utf8_info</code> structures.
649      *
650      * @param name <code>name_index</code>
651      * @param type <code>descriptor_index</code>
652      * @return the index of the added entry.
653      */
654     public int addNameAndTypeInfo(String name, String type) {
655         return addNameAndTypeInfo(addUtf8Info(name), addUtf8Info(type));
656     }
657
658     /**
659      * Adds a new <code>CONSTANT_NameAndType_info</code> structure.
660      *
661      * @param name <code>name_index</code>
662      * @param type <code>descriptor_index</code>
663      * @return the index of the added entry.
664      */
665     public int addNameAndTypeInfo(int name, int type) {
666         return addItem(new NameAndTypeInfo(name, type));
667     }
668
669     /**
670      * Adds a new <code>CONSTANT_Fieldref_info</code> structure.
671      *
672      * <p>This also adds a new <code>CONSTANT_NameAndType_info</code>
673      * structure.
674      *
675      * @param classInfo <code>class_index</code>
676      * @param name <code>name_index</code>
677      * of <code>CONSTANT_NameAndType_info</code>.
678      * @param type <code>descriptor_index</code>
679      * of <code>CONSTANT_NameAndType_info</code>.
680      * @return the index of the added entry.
681      */
682     public int addFieldrefInfo(int classInfo, String name, String type) {
683         int nt = addNameAndTypeInfo(name, type);
684         return addFieldrefInfo(classInfo, nt);
685     }
686
687     /**
688      * Adds a new <code>CONSTANT_Fieldref_info</code> structure.
689      *
690      * @param classInfo <code>class_index</code>
691      * @param nameAndTypeInfo <code>name_and_type_index</code>.
692      * @return the index of the added entry.
693      */
694     public int addFieldrefInfo(int classInfo, int nameAndTypeInfo) {
695         return addItem(new FieldrefInfo(classInfo, nameAndTypeInfo));
696     }
697
698     /**
699      * Adds a new <code>CONSTANT_Methodref_info</code> structure.
700      *
701      * <p>This also adds a new <code>CONSTANT_NameAndType_info</code>
702      * structure.
703      *
704      * @param classInfo <code>class_index</code>
705      * @param name <code>name_index</code>
706      * of <code>CONSTANT_NameAndType_info</code>.
707      * @param type <code>descriptor_index</code>
708      * of <code>CONSTANT_NameAndType_info</code>.
709      * @return the index of the added entry.
710      */
711     public int addMethodrefInfo(int classInfo, String name, String type) {
712         int nt = addNameAndTypeInfo(name, type);
713         return addMethodrefInfo(classInfo, nt);
714     }
715
716     /**
717      * Adds a new <code>CONSTANT_Methodref_info</code> structure.
718      *
719      * @param classInfo <code>class_index</code>
720      * @param nameAndTypeInfo <code>name_and_type_index</code>.
721      * @return the index of the added entry.
722      */
723     public int addMethodrefInfo(int classInfo, int nameAndTypeInfo) {
724         return addItem(new MethodrefInfo(classInfo, nameAndTypeInfo));
725     }
726
727     /**
728      * Adds a new <code>CONSTANT_InterfaceMethodref_info</code>
729      * structure.
730      *
731      * <p>This also adds a new <code>CONSTANT_NameAndType_info</code>
732      * structure.
733      *
734      * @param classInfo <code>class_index</code>
735      * @param name <code>name_index</code>
736      * of <code>CONSTANT_NameAndType_info</code>.
737      * @param type <code>descriptor_index</code>
738      * of <code>CONSTANT_NameAndType_info</code>.
739      * @return the index of the added entry.
740      */
741     public int addInterfaceMethodrefInfo(int classInfo, String name,
742                                          String type) {
743         int nt = addNameAndTypeInfo(name, type);
744         return addInterfaceMethodrefInfo(classInfo, nt);
745     }
746
747     /**
748      * Adds a new <code>CONSTANT_InterfaceMethodref_info</code>
749      * structure.
750      *
751      * @param classInfo <code>class_index</code>
752      * @param nameAndTypeInfo <code>name_and_type_index</code>.
753      * @return the index of the added entry.
754      */
755     public int addInterfaceMethodrefInfo(int classInfo,
756                                          int nameAndTypeInfo) {
757         return addItem(new InterfaceMethodrefInfo(classInfo,
758                                                   nameAndTypeInfo));
759     }
760
761     /**
762      * Adds a new <code>CONSTANT_String_info</code>
763      * structure.
764      *
765      * <p>This also adds a new <code>CONSTANT_Utf8_info</code>
766      * structure.
767      *
768      * @return the index of the added entry.
769      */
770     public int addStringInfo(String str) {
771         return addItem(new StringInfo(addUtf8Info(str)));
772     }
773
774     /**
775      * Adds a new <code>CONSTANT_Integer_info</code>
776      * structure.
777      *
778      * @return the index of the added entry.
779      */
780     public int addIntegerInfo(int i) {
781         return addItem(new IntegerInfo(i));
782     }
783
784     /**
785      * Adds a new <code>CONSTANT_Float_info</code>
786      * structure.
787      *
788      * @return the index of the added entry.
789      */
790     public int addFloatInfo(float f) {
791         return addItem(new FloatInfo(f));
792     }
793
794     /**
795      * Adds a new <code>CONSTANT_Long_info</code>
796      * structure.
797      *
798      * @return the index of the added entry.
799      */
800     public int addLongInfo(long l) {
801         int i = addItem(new LongInfo(l));
802         addItem(new ConstInfoPadding());
803         return i;
804     }
805
806     /**
807      * Adds a new <code>CONSTANT_Double_info</code>
808      * structure.
809      *
810      * @return the index of the added entry.
811      */
812     public int addDoubleInfo(double d) {
813         int i = addItem(new DoubleInfo(d));
814         addItem(new ConstInfoPadding());
815         return i;
816     }
817
818     /**
819      * Adds a new <code>CONSTANT_Utf8_info</code>
820      * structure.
821      *
822      * <p>If the given utf8 string has been already recorded in the
823      * table, then this method does not add a new entry to avoid adding
824      * a duplicated entry.
825      * Instead, it returns the index of the entry already recorded.
826      *
827      * @return the index of the added entry.
828      */
829     public int addUtf8Info(String utf8) {
830         Utf8Info info = (Utf8Info)strings.get(utf8);
831         if (info != null)
832             return info.index;
833         else {
834             info = new Utf8Info(utf8, numOfItems);
835             strings.put(utf8, info);
836             return addItem(info);
837         }
838     }
839
840     /**
841      * Replaces all occurrences of a class name.
842      *
843      * @param oldName the replaced name
844      * @param newName the substituted name.
845      */
846     public void renameClass(String oldName, String newName) {
847         LongVector v = items;
848         int size = numOfItems;
849         for (int i = 1; i < size; ++i)
850             ((ConstInfo)v.elementAt(i)).renameClass(this, oldName, newName);
851     }
852
853     /**
854      * Replaces all occurrences of class names.
855      *
856      * @param classnames specifies pairs of replaced and substituted
857      * name.
858      */
859     public void renameClass(Map classnames) {
860         LongVector v = items;
861         int size = numOfItems;
862         for (int i = 1; i < size; ++i)
863             ((ConstInfo)v.elementAt(i)).renameClass(this, classnames);
864     }
865
866     private void read(DataInputStream in) throws IOException {
867         int n = in.readUnsignedShort();
868
869         int size = (n / LongVector.SIZE + 1) * LongVector.SIZE;
870         items = new LongVector(size);
871         numOfItems = 0;
872         addItem(null); // index 0 is reserved by the JVM.
873
874         while (--n > 0) { // index 0 is reserved by JVM
875 int tag = readOne(in);
876             if ((tag == LongInfo.tag) || (tag == DoubleInfo.tag)) {
877                 addItem(new ConstInfoPadding());
878                 --n;
879             }
880         }
881     }
882
883     private int readOne(DataInputStream in) throws IOException {
884         ConstInfo info;
885         int tag = in.readUnsignedByte();
886         switch (tag) {
887         case Utf8Info.tag : // 1
888 info = new Utf8Info(in, numOfItems);
889             strings.put(((Utf8Info)info).string, info);
890             break;
891         case IntegerInfo.tag : // 3
892 info = new IntegerInfo(in);
893             break;
894         case FloatInfo.tag : // 4
895 info = new FloatInfo(in);
896             break;
897         case LongInfo.tag : // 5
898 info = new LongInfo(in);
899             break;
900         case DoubleInfo.tag : // 6
901 info = new DoubleInfo(in);
902             break;
903         case ClassInfo.tag : // 7
904 info = new ClassInfo(in, numOfItems);
905             // classes.put(<classname>, info);
906 break;
907         case StringInfo.tag : // 8
908 info = new StringInfo(in);
909             break;
910         case FieldrefInfo.tag : // 9
911 info = new FieldrefInfo(in);
912             break;
913         case MethodrefInfo.tag : // 10
914 info = new MethodrefInfo(in);
915             break;
916         case InterfaceMethodrefInfo.tag : // 11
917 info = new InterfaceMethodrefInfo(in);
918             break;
919         case NameAndTypeInfo.tag : // 12
920 info = new NameAndTypeInfo(in);
921             break;
922         default :
923             throw new IOException ("invalid constant type: " + tag);
924         }
925
926         addItem(info);
927         return tag;
928     }
929
930     /**
931      * Writes the contents of the constant pool table.
932      */
933     public void write(DataOutputStream out) throws IOException {
934         out.writeShort(numOfItems);
935         LongVector v = items;
936         int size = numOfItems;
937         for (int i = 1; i < size; ++i)
938             ((ConstInfo)v.elementAt(i)).write(out);
939     }
940
941     /**
942      * Prints the contents of the constant pool table.
943      */
944     public void print() {
945         print(new PrintWriter (System.out, true));
946     }
947
948     /**
949      * Prints the contents of the constant pool table.
950      */
951     public void print(PrintWriter out) {
952         int size = numOfItems;
953         for (int i = 1; i < size; ++i) {
954             out.print(i);
955             out.print(" ");
956             ((ConstInfo)items.elementAt(i)).print(out);
957         }
958