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
|
/*
* 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;
import javassist.CtMethod.ConstParameter;
import javassist.bytecode.Bytecode;
import javassist.bytecode.ClassFile;
import javassist.bytecode.Descriptor;
class CtNewWrappedConstructor extends CtNewWrappedMethod {
private static final int PASS_NONE = CtNewConstructor.PASS_NONE;
// private static final int PASS_ARRAY = CtNewConstructor.PASS_ARRAY;
private static final int PASS_PARAMS = CtNewConstructor.PASS_PARAMS;
public static CtConstructor wrapped(CtClass[] parameterTypes,
CtClass[] exceptionTypes,
int howToCallSuper,
CtMethod body,
ConstParameter constParam,
CtClass declaring)
throws CannotCompileException
{
try {
CtConstructor cons = new CtConstructor(parameterTypes, declaring);
cons.setExceptionTypes(exceptionTypes);
Bytecode code = makeBody(declaring, declaring.getClassFile2(),
howToCallSuper, body,
parameterTypes, constParam);
cons.getMethodInfo2().setCodeAttribute(code.toCodeAttribute());
// a stack map table is not needed.
return cons;
}
catch (NotFoundException e) {
throw new CannotCompileException(e);
}
}
protected static Bytecode makeBody(CtClass declaring, ClassFile classfile,
int howToCallSuper,
CtMethod wrappedBody,
CtClass[] parameters,
ConstParameter cparam)
throws CannotCompileException
{
int stacksize, stacksize2;
int superclazz = classfile.getSuperclassId();
Bytecode code = new Bytecode(classfile.getConstPool(), 0, 0);
code.setMaxLocals(false, parameters, 0);
code.addAload(0);
if (howToCallSuper == PASS_NONE) {
stacksize = 1;
code.addInvokespecial(superclazz, "<init>", "()V");
}
else if (howToCallSuper == PASS_PARAMS) {
stacksize = code.addLoadParameters(parameters, 1) + 1;
code.addInvokespecial(superclazz, "<init>",
Descriptor.ofConstructor(parameters));
}
else {
stacksize = compileParameterList(code, parameters, 1);
String desc;
if (cparam == null) {
stacksize2 = 2;
desc = ConstParameter.defaultConstDescriptor();
}
else {
stacksize2 = cparam.compile(code) + 2;
desc = cparam.constDescriptor();
}
if (stacksize < stacksize2)
stacksize = stacksize2;
code.addInvokespecial(superclazz, "<init>", desc);
}
if (wrappedBody == null)
code.add(Bytecode.RETURN);
else {
stacksize2 = makeBody0(declaring, classfile, wrappedBody,
false, parameters, CtClass.voidType,
cparam, code);
if (stacksize < stacksize2)
stacksize = stacksize2;
}
code.setMaxStack(stacksize);
return code;
}
}
|
