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
|
/*
* This file is part of the Javassist toolkit.
*
* 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. You may obtain a copy of the License at
* either http://www.mozilla.org/MPL/.
*
* 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.
*
* The Original Code is Javassist.
*
* The Initial Developer of the Original Code is Shigeru Chiba. Portions
* created by Shigeru Chiba are Copyright (C) 1999-2003 Shigeru Chiba.
* All Rights Reserved.
*
* Contributor(s):
*
* The development of this software is supported in part by the PRESTO
* program (Sakigake Kenkyu 21) of Japan Science and Technology Corporation.
*/
package javassist;
import javassist.bytecode.*;
import javassist.CtMethod.ConstParameter;
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());
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;
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;
}
}
|
