1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
|
/*
* Javassist, a Java-bytecode translator toolkit.
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. Alternatively, the contents of this file may be used under
* the terms of the GNU Lesser General Public License Version 2.1 or later,
* or the Apache License Version 2.0.
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*/
package javassist.expr;
import java.util.LinkedList;
import java.util.List;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtBehavior;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtPrimitiveType;
import javassist.NotFoundException;
import javassist.bytecode.AccessFlag;
import javassist.bytecode.BadBytecode;
import javassist.bytecode.Bytecode;
import javassist.bytecode.ClassFile;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.CodeIterator;
import javassist.bytecode.ConstPool;
import javassist.bytecode.ExceptionTable;
import javassist.bytecode.ExceptionsAttribute;
import javassist.bytecode.MethodInfo;
import javassist.bytecode.Opcode;
import javassist.compiler.Javac;
/**
* Expression.
*/
public abstract class Expr implements Opcode {
int currentPos;
CodeIterator iterator;
CtClass thisClass;
MethodInfo thisMethod;
boolean edited;
int maxLocals, maxStack;
static final String javaLangObject = "java.lang.Object";
/**
* Undocumented constructor. Do not use; internal-use only.
*/
protected Expr(int pos, CodeIterator i, CtClass declaring, MethodInfo m) {
currentPos = pos;
iterator = i;
thisClass = declaring;
thisMethod = m;
}
/**
* Returns the class that declares the method enclosing
* this expression.
*
* @since 3.7
*/
public CtClass getEnclosingClass() { return thisClass; }
protected final ConstPool getConstPool() {
return thisMethod.getConstPool();
}
protected final boolean edited() {
return edited;
}
protected final int locals() {
return maxLocals;
}
protected final int stack() {
return maxStack;
}
/**
* Returns true if this method is static.
*/
protected final boolean withinStatic() {
return (thisMethod.getAccessFlags() & AccessFlag.STATIC) != 0;
}
/**
* Returns the constructor or method containing the expression.
*/
public CtBehavior where() {
MethodInfo mi = thisMethod;
CtBehavior[] cb = thisClass.getDeclaredBehaviors();
for (int i = cb.length - 1; i >= 0; --i)
if (cb[i].getMethodInfo2() == mi)
return cb[i];
CtConstructor init = thisClass.getClassInitializer();
if (init != null && init.getMethodInfo2() == mi)
return init;
/* getDeclaredBehaviors() returns a list of methods/constructors.
* Although the list is cached in a CtClass object, it might be
* recreated for some reason. Thus, the member name and the signature
* must be also checked.
*/
for (int i = cb.length - 1; i >= 0; --i) {
if (thisMethod.getName().equals(cb[i].getMethodInfo2().getName())
&& thisMethod.getDescriptor()
.equals(cb[i].getMethodInfo2().getDescriptor())) {
return cb[i];
}
}
throw new RuntimeException("fatal: not found");
}
/**
* Returns the list of exceptions that the expression may throw. This list
* includes both the exceptions that the try-catch statements including the
* expression can catch and the exceptions that the throws declaration
* allows the method to throw.
*/
public CtClass[] mayThrow() {
ClassPool pool = thisClass.getClassPool();
ConstPool cp = thisMethod.getConstPool();
List<CtClass> list = new LinkedList<CtClass>();
try {
CodeAttribute ca = thisMethod.getCodeAttribute();
ExceptionTable et = ca.getExceptionTable();
int pos = currentPos;
int n = et.size();
for (int i = 0; i < n; ++i)
if (et.startPc(i) <= pos && pos < et.endPc(i)) {
int t = et.catchType(i);
if (t > 0)
try {
addClass(list, pool.get(cp.getClassInfo(t)));
}
catch (NotFoundException e) {
}
}
}
catch (NullPointerException e) {
}
ExceptionsAttribute ea = thisMethod.getExceptionsAttribute();
if (ea != null) {
String[] exceptions = ea.getExceptions();
if (exceptions != null) {
int n = exceptions.length;
for (int i = 0; i < n; ++i)
try {
addClass(list, pool.get(exceptions[i]));
}
catch (NotFoundException e) {
}
}
}
return list.toArray(new CtClass[list.size()]);
}
private static void addClass(List<CtClass> list, CtClass c) {
if (list.contains(c))
return;
list.add(c);
}
/**
* Returns the index of the bytecode corresponding to the expression. It is
* the index into the byte array containing the Java bytecode that
* implements the method.
*/
public int indexOfBytecode() {
return currentPos;
}
/**
* Returns the line number of the source line containing the expression.
*
* @return -1 if this information is not available.
*/
public int getLineNumber() {
return thisMethod.getLineNumber(currentPos);
}
/**
* Returns the source file containing the expression.
*
* @return null if this information is not available.
*/
public String getFileName() {
ClassFile cf = thisClass.getClassFile2();
if (cf == null)
return null;
return cf.getSourceFile();
}
static final boolean checkResultValue(CtClass retType, String prog)
throws CannotCompileException {
/*
* Is $_ included in the source code?
*/
boolean hasIt = (prog.indexOf(Javac.resultVarName) >= 0);
if (!hasIt && retType != CtClass.voidType)
throw new CannotCompileException(
"the resulting value is not stored in "
+ Javac.resultVarName);
return hasIt;
}
/*
* If isStaticCall is true, null is assigned to $0. So $0 must be declared
* by calling Javac.recordParams().
*
* After executing this method, the current stack depth might be less than
* 0.
*/
static final void storeStack(CtClass[] params, boolean isStaticCall,
int regno, Bytecode bytecode) {
storeStack0(0, params.length, params, regno + 1, bytecode);
if (isStaticCall)
bytecode.addOpcode(ACONST_NULL);
bytecode.addAstore(regno);
}
private static void storeStack0(int i, int n, CtClass[] params, int regno,
Bytecode bytecode) {
if (i >= n)
return;
CtClass c = params[i];
int size;
if (c instanceof CtPrimitiveType)
size = ((CtPrimitiveType)c).getDataSize();
else
size = 1;
storeStack0(i + 1, n, params, regno + size, bytecode);
bytecode.addStore(regno, c);
}
// The implementation of replace() should call thisClass.checkModify()
// so that isModify() will return true. Otherwise, thisClass.classfile
// might be released during compilation and the compiler might generate
// bytecode with a wrong copy of ConstPool.
/**
* Replaces this expression with the bytecode derived from
* the given source text.
*
* @param statement a Java statement except try-catch.
*/
public abstract void replace(String statement) throws CannotCompileException;
/**
* Replaces this expression with the bytecode derived from
* the given source text and <code>ExprEditor</code>.
*
* @param statement a Java statement except try-catch.
* @param recursive if not null, the substituted bytecode
* is recursively processed by the given
* <code>ExprEditor</code>.
* @since 3.1
*/
public void replace(String statement, ExprEditor recursive)
throws CannotCompileException
{
replace(statement);
if (recursive != null)
runEditor(recursive, iterator);
}
protected void replace0(int pos, Bytecode bytecode, int size)
throws BadBytecode {
byte[] code = bytecode.get();
edited = true;
int gap = code.length - size;
for (int i = 0; i < size; ++i)
iterator.writeByte(NOP, pos + i);
if (gap > 0)
pos = iterator.insertGapAt(pos, gap, false).position;
iterator.write(code, pos);
iterator.insert(bytecode.getExceptionTable(), pos);
maxLocals = bytecode.getMaxLocals();
maxStack = bytecode.getMaxStack();
}
protected void runEditor(ExprEditor ed, CodeIterator oldIterator)
throws CannotCompileException
{
CodeAttribute codeAttr = oldIterator.get();
int orgLocals = codeAttr.getMaxLocals();
int orgStack = codeAttr.getMaxStack();
int newLocals = locals();
codeAttr.setMaxStack(stack());
codeAttr.setMaxLocals(newLocals);
ExprEditor.LoopContext context
= new ExprEditor.LoopContext(newLocals);
int size = oldIterator.getCodeLength();
int endPos = oldIterator.lookAhead();
oldIterator.move(currentPos);
if (ed.doit(thisClass, thisMethod, context, oldIterator, endPos))
edited = true;
oldIterator.move(endPos + oldIterator.getCodeLength() - size);
codeAttr.setMaxLocals(orgLocals);
codeAttr.setMaxStack(orgStack);
maxLocals = context.maxLocals;
maxStack += context.maxStack;
}
}
|