1 /*
2 * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 package jdk.experimental.bytecode;
25
26 import java.util.function.Consumer;
27
28 /**
29 * Base class builder. The base of higher level class builders.
30 *
31 * @param <S> the type of symbol representation
32 * @param <T> the type of type descriptors representation
33 * @param <C> the type of this builder
34 */
35 public class ClassBuilder<S, T, C extends ClassBuilder<S, T, C>>
36 extends DeclBuilder<S, T, byte[], C> {
37
38 /**
39 * The helper to use to manipulate type descriptors.
40 */
41 protected TypeHelper<S, T> typeHelper;
42
43 /**
44 * The symbol for the class being built.
45 */
46 protected S thisClass;
47
48 /**
49 * The super-interfaces of the class being built..
50 */
51 protected GrowableByteBuffer interfaces = new GrowableByteBuffer();
52
53 /**
54 * The fields of the class being built.
55 */
56 protected GrowableByteBuffer fields = new GrowableByteBuffer();
57
58 /**
59 * The methods of the class being built.
60 */
61 protected GrowableByteBuffer methods = new GrowableByteBuffer();
62
63 int majorVersion;
64 int minorVersion;
65 int flags;
66 int superclass;
67 int nmethods, nfields, ninterfaces;
68
69 /**
70 * Create a class builder.
71 *
72 * @param poolHelper the helper to build the constant pool
73 * @param typeHelper the helper to use to manipulate type descriptors
74 */
75 public ClassBuilder(BytePoolHelper<S, T> poolHelper, TypeHelper<S, T> typeHelper) {
76 super(poolHelper, typeHelper);
77 this.typeHelper = typeHelper;
78 }
79
80 /**
81 * Set the minor class file version.
82 *
83 * @param minorVersion the minor version number
84 * @return this builder, for chained calls
85 */
86 public C withMinorVersion(int minorVersion) {
87 this.minorVersion = minorVersion;
88 return thisBuilder();
89 }
90
91 /**
92 * Set the major class file version.
93 *
94 * @param majorVersion the major version number
95 * @return this builder, for chained calls
96 */
97 public C withMajorVersion(int majorVersion) {
98 this.majorVersion = majorVersion;
99 return thisBuilder();
100 }
101
102 /**
103 * Set the class symbol
104 *
105 * @param thisClass the class symbol
106 * @return this builder, for chained calls
107 */
108 public C withThisClass(S thisClass) {
109 this.thisClass = thisClass;
110 return thisBuilder();
111 }
112
113 /**
114 * Set the class access flags
115 *
116 * @param flags an array of {@code Flag}
117 * @return this builder, for chained calls
118 */
119 @Override
120 public C withFlags(Flag... flags) {
121 for (Flag f : flags) {
122 this.flags |= f.flag;
123 }
124 return thisBuilder();
125 }
126
127 /**
128 * Set the superclass
129 *
130 * @param sup the superclass symbol
131 * @return this builder, for chained calls
132 */
133 public C withSuperclass(S sup) {
134 this.superclass = poolHelper.putClass(sup);
135 return thisBuilder();
136 }
137
138 /**
139 * Add a super interface.
140 *
141 * @param sup an interface symbol
142 * @return this builder, for chained calls
143 */
144 public C withSuperinterface(S sup) {
145 this.interfaces.writeChar(poolHelper.putClass(sup));
146 ninterfaces++;
147 return thisBuilder();
148 }
149
150 /**
151 * Add a field.
152 *
153 * @param name the name of the field
154 * @param type the type descriptor of the field
155 * @return this builder, for chained calls
156 */
157 public final C withField(CharSequence name, T type) {
158 return withField(name, type, FB -> {
159 });
160 }
161
162 /**
163 * Add a field.
164 *
165 * @param name the name of the field
166 * @param type the type descriptor of the field
167 * @param fieldConfig access to the {@code FieldBuilder} to allow clients to
168 * adjust flags, annotations and bytecode attributes on the field declaration
169 * @return this builder, for chained calls
170 */
171 public C withField(CharSequence name, T type, Consumer<? super FieldBuilder<S, T, byte[]>> fieldConfig) {
172 FieldBuilder<S, T, byte[]> F = new FieldBuilder<>(name, type, poolHelper, typeHelper);
173 fieldConfig.accept(F);
174 F.build(fields);
175 nfields++;
176 return thisBuilder();
177 }
178
179 /**
180 * Add a method
181 *
182 * @param name the name of the method
183 * @param type the type descriptor of the method
184 * @return this builder, for chained calls
185 */
186 public final C withMethod(CharSequence name, T type) {
187 return withMethod(name, type, MB -> {
188 });
189 }
190
191 /**
192 * Add a method
193 *
194 * @param name the name of the method
195 * @param type the type descriptor of the method
196 * @param methodConfig access to the {@code MethodBuilder} to allow clients to
197 * adjust flags, annotations and bytecode attributes on the method declaration
198 * @return this builder, for chained calls
199 */
200 public C withMethod(CharSequence name, T type, Consumer<? super MethodBuilder<S, T, byte[]>> methodConfig) {
201 MethodBuilder<S, T, byte[]> M = new MethodBuilder<>(thisClass, name, type, poolHelper, typeHelper);
202 methodConfig.accept(M);
203 M.build(methods);
204 nmethods++;
205 return thisBuilder();
206 }
207
208 /**
209 * Build the constant pool into a byte array.
210 *
211 * @return a representation of this constant pool as a byte array
212 */
213 @SuppressWarnings("unchecked")
214 public byte[] build() {
215 ((BytePoolHelper<S, T>)poolHelper).addAttributes(this);
216 addAnnotations();
217 int thisClassIdx = poolHelper.putClass(thisClass);
218 byte[] poolBytes = poolHelper.entries();
219 GrowableByteBuffer buf = new GrowableByteBuffer();
220 buf.writeInt(0xCAFEBABE);
221 buf.writeChar(minorVersion);
222 buf.writeChar(majorVersion);
223 buf.writeChar(poolHelper.size() + 1);
224 buf.writeBytes(poolBytes);
225 buf.writeChar(flags);
226 buf.writeChar(thisClassIdx);
227 buf.writeChar(superclass);
228 buf.writeChar(ninterfaces);
229 if (ninterfaces > 0) {
230 buf.writeBytes(interfaces);
231 }
232 buf.writeChar(nfields);
233 buf.writeBytes(fields);
234 buf.writeChar(nmethods);
235 buf.writeBytes(methods);
236 buf.writeChar(nattrs);
237 buf.writeBytes(attributes);
238 return buf.bytes();
239 }
240 }