1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.bcel.classfile;
18
19 import java.io.DataInputStream;
20 import java.io.DataOutputStream;
21 import java.io.IOException;
22 import java.io.Serializable;
23 import org.apache.bcel.Constants;
24
25 /***
26 * This class represents a local variable within a method. It contains its
27 * scope, name, signature and index on the method's frame.
28 *
29 * @version $Id: LocalVariable.java 386056 2006-03-15 11:31:56Z tcurdt $
30 * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
31 * @see LocalVariableTable
32 */
33 public final class LocalVariable implements Constants, Cloneable, Node, Serializable {
34
35 private int start_pc;
36 private int length;
37 private int name_index;
38 private int signature_index;
39 private int index;
40
41
42 private ConstantPool constant_pool;
43
44
45 /***
46 * Initialize from another object. Note that both objects use the same
47 * references (shallow copy). Use copy() for a physical copy.
48 */
49 public LocalVariable(LocalVariable c) {
50 this(c.getStartPC(), c.getLength(), c.getNameIndex(), c.getSignatureIndex(), c.getIndex(),
51 c.getConstantPool());
52 }
53
54
55 /***
56 * Construct object from file stream.
57 * @param file Input stream
58 * @throws IOException
59 */
60 LocalVariable(DataInputStream file, ConstantPool constant_pool) throws IOException {
61 this(file.readUnsignedShort(), file.readUnsignedShort(), file.readUnsignedShort(), file
62 .readUnsignedShort(), file.readUnsignedShort(), constant_pool);
63 }
64
65
66 /***
67 * @param start_pc Range in which the variable
68 * @param length ... is valid
69 * @param name_index Index in constant pool of variable name
70 * @param signature_index Index of variable's signature
71 * @param index Variable is `index'th local variable on the method's frame
72 * @param constant_pool Array of constants
73 */
74 public LocalVariable(int start_pc, int length, int name_index, int signature_index, int index,
75 ConstantPool constant_pool) {
76 this.start_pc = start_pc;
77 this.length = length;
78 this.name_index = name_index;
79 this.signature_index = signature_index;
80 this.index = index;
81 this.constant_pool = constant_pool;
82 }
83
84
85 /***
86 * Called by objects that are traversing the nodes of the tree implicitely
87 * defined by the contents of a Java class. I.e., the hierarchy of methods,
88 * fields, attributes, etc. spawns a tree of objects.
89 *
90 * @param v Visitor object
91 */
92 public void accept( Visitor v ) {
93 v.visitLocalVariable(this);
94 }
95
96
97 /***
98 * Dump local variable to file stream in binary format.
99 *
100 * @param file Output file stream
101 * @throws IOException
102 */
103 public final void dump( DataOutputStream file ) throws IOException {
104 file.writeShort(start_pc);
105 file.writeShort(length);
106 file.writeShort(name_index);
107 file.writeShort(signature_index);
108 file.writeShort(index);
109 }
110
111
112 /***
113 * @return Constant pool used by this object.
114 */
115 public final ConstantPool getConstantPool() {
116 return constant_pool;
117 }
118
119
120 /***
121 * @return Variable is valid within getStartPC() .. getStartPC()+getLength()
122 */
123 public final int getLength() {
124 return length;
125 }
126
127
128 /***
129 * @return Variable name.
130 */
131 public final String getName() {
132 ConstantUtf8 c;
133 c = (ConstantUtf8) constant_pool.getConstant(name_index, CONSTANT_Utf8);
134 return c.getBytes();
135 }
136
137
138 /***
139 * @return Index in constant pool of variable name.
140 */
141 public final int getNameIndex() {
142 return name_index;
143 }
144
145
146 /***
147 * @return Signature.
148 */
149 public final String getSignature() {
150 ConstantUtf8 c;
151 c = (ConstantUtf8) constant_pool.getConstant(signature_index, CONSTANT_Utf8);
152 return c.getBytes();
153 }
154
155
156 /***
157 * @return Index in constant pool of variable signature.
158 */
159 public final int getSignatureIndex() {
160 return signature_index;
161 }
162
163
164 /***
165 * @return index of register where variable is stored
166 */
167 public final int getIndex() {
168 return index;
169 }
170
171
172 /***
173 * @return Start of range where he variable is valid
174 */
175 public final int getStartPC() {
176 return start_pc;
177 }
178
179
180 /***
181 * @param constant_pool Constant pool to be used for this object.
182 */
183 public final void setConstantPool( ConstantPool constant_pool ) {
184 this.constant_pool = constant_pool;
185 }
186
187
188 /***
189 * @param length the length of this local variable
190 */
191 public final void setLength( int length ) {
192 this.length = length;
193 }
194
195
196 /***
197 * @param name_index the index into the constant pool for the name of this variable
198 */
199 public final void setNameIndex( int name_index ) {
200 this.name_index = name_index;
201 }
202
203
204 /***
205 * @param signature_index the index into the constant pool for the signature of this variable
206 */
207 public final void setSignatureIndex( int signature_index ) {
208 this.signature_index = signature_index;
209 }
210
211
212 /***
213 * @param index the index in the local variable table of this variable
214 */
215 public final void setIndex( int index ) {
216 this.index = index;
217 }
218
219
220 /***
221 * @param start_pc Specify range where the local variable is valid.
222 */
223 public final void setStartPC( int start_pc ) {
224 this.start_pc = start_pc;
225 }
226
227
228 /***
229 * @return string representation.
230 */
231 public final String toString() {
232 String name = getName(), signature = Utility.signatureToString(getSignature());
233 return "LocalVariable(start_pc = " + start_pc + ", length = " + length + ", index = "
234 + index + ":" + signature + " " + name + ")";
235 }
236
237
238 /***
239 * @return deep copy of this object
240 */
241 public LocalVariable copy() {
242 try {
243 return (LocalVariable) clone();
244 } catch (CloneNotSupportedException e) {
245 }
246 return null;
247 }
248 }