History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/invoke/anon/ConstantPoolParser.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/invoke/anon/ConstantPoolParser.java+368−0
@@ -0,0 +1,368 @@
1/*
2 * Copyright (c) 2008, 2011, 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. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package sun.invoke.anon;
27
28import java.io.IOException;
29import java.io.OutputStream;
30import java.nio.BufferUnderflowException;
31import java.nio.ByteBuffer;
32
33import static sun.invoke.anon.ConstantPoolVisitor.*;
34
35/** A constant pool parser.
36 */
37public class ConstantPoolParser {
38 final byte[] classFile;
39 final byte[] tags;
40 final char[] firstHeader; // maghi, maglo, minor, major, cplen
41
42 // these are filled in on first parse:
43 int endOffset;
44 char[] secondHeader; // flags, this_class, super_class, intlen
45
46 // used to decode UTF8 array
47 private char[] charArray = new char[80];
48
49 /** Creates a constant pool parser.
50 * @param classFile an array of bytes containing a class.
51 * @throws InvalidConstantPoolFormatException if the header of the class has errors.
52 */
53 public ConstantPoolParser(byte[] classFile) throws InvalidConstantPoolFormatException {
54 this.classFile = classFile;
55 this.firstHeader = parseHeader(classFile);
56 this.tags = new byte[firstHeader[4]];
57 }
58
59 /** Create a constant pool parser by loading the bytecodes of the
60 * class taken as argument.
61 *
62 * @param templateClass the class to parse.
63 *
64 * @throws IOException raised if an I/O occurs when loading
65 * the bytecode of the template class.
66 * @throws InvalidConstantPoolFormatException if the header of the class has errors.
67 *
68 * @see #ConstantPoolParser(byte[])
69 * @see AnonymousClassLoader#readClassFile(Class)
70 */
71 public ConstantPoolParser(Class<?> templateClass) throws IOException, InvalidConstantPoolFormatException {
72 this(AnonymousClassLoader.readClassFile(templateClass));
73 }
74
75 /** Creates an empty patch to patch the class file
76 * used by the current parser.
77 * @return a new class patch.
78 */
79 public ConstantPoolPatch createPatch() {
80 return new ConstantPoolPatch(this);
81 }
82
83 /** Report the tag of the indicated CP entry.
84 * @param index
85 * @return one of {@link ConstantPoolVisitor#CONSTANT_Utf8}, etc.
86 */
87 public byte getTag(int index) {
88 getEndOffset(); // trigger an exception if we haven't parsed yet
89 return tags[index];
90 }
91
92 /** Report the length of the constant pool. */
93 public int getLength() {
94 return firstHeader[4];
95 }
96
97 /** Report the offset, within the class file, of the start of the constant pool. */
98 public int getStartOffset() {
99 return firstHeader.length * 2;
100 }
101
102 /** Report the offset, within the class file, of the end of the constant pool. */
103 public int getEndOffset() {
104 if (endOffset == 0)
105 throw new IllegalStateException("class file has not yet been parsed");
106 return endOffset;
107 }
108
109 /** Report the CP index of this class's own name. */
110 public int getThisClassIndex() {
111 getEndOffset(); // provoke exception if not yet parsed
112 return secondHeader[1];
113 }
114
115 /** Report the total size of the class file. */
116 public int getTailLength() {
117 return classFile.length - getEndOffset();
118 }
119
120 /** Write the head (header plus constant pool)
121 * of the class file to the indicated stream.
122 */
123 public void writeHead(OutputStream out) throws IOException {
124 out.write(classFile, 0, getEndOffset());
125 }
126
127 /** Write the head (header plus constant pool)
128 * of the class file to the indicated stream,
129 * incorporating the non-null entries of the given array
130 * as patches.
131 */
132 void writePatchedHead(OutputStream out, Object[] patchArray) {
133 // this will be useful to partially emulate the class loader on old JVMs
134 throw new UnsupportedOperationException("Not yet implemented");
135 }
136
137 /** Write the tail (everything after the constant pool)
138 * of the class file to the indicated stream.
139 */
140 public void writeTail(OutputStream out) throws IOException {
141 out.write(classFile, getEndOffset(), getTailLength());
142 }
143
144 private static char[] parseHeader(byte[] classFile) throws InvalidConstantPoolFormatException {
145 char[] result = new char[5];
146 ByteBuffer buffer = ByteBuffer.wrap(classFile);
147 for (int i = 0; i < result.length; i++)
148 result[i] = (char) getUnsignedShort(buffer);
149 int magic = result[0] << 16 | result[1] << 0;
150 if (magic != 0xCAFEBABE)
151 throw new InvalidConstantPoolFormatException("invalid magic number "+magic);
152 // skip major, minor version
153 int len = result[4];
154 if (len < 1)
155 throw new InvalidConstantPoolFormatException("constant pool length < 1");
156 return result;
157 }
158
159 /** Parse the constant pool of the class
160 * calling a method visit* each time a constant pool entry is parsed.
161 *
162 * The order of the calls to visit* is not guaranteed to be the same
163 * than the order of the constant pool entry in the bytecode array.
164 *
165 * @param visitor
166 * @throws InvalidConstantPoolFormatException
167 */
168 public void parse(ConstantPoolVisitor visitor) throws InvalidConstantPoolFormatException {
169 ByteBuffer buffer = ByteBuffer.wrap(classFile);
170 buffer.position(getStartOffset()); //skip header
171
172 Object[] values = new Object[getLength()];
173 try {
174 parseConstantPool(buffer, values, visitor);
175 } catch(BufferUnderflowException e) {
176 throw new InvalidConstantPoolFormatException(e);
177 }
178 if (endOffset == 0) {
179 endOffset = buffer.position();
180 secondHeader = new char[4];
181 for (int i = 0; i < secondHeader.length; i++) {
182 secondHeader[i] = (char) getUnsignedShort(buffer);
183 }
184 }
185 resolveConstantPool(values, visitor);
186 }
187
188 private char[] getCharArray(int utfLength) {
189 if (utfLength <= charArray.length)
190 return charArray;
191 return charArray = new char[utfLength];
192 }
193
194 private void parseConstantPool(ByteBuffer buffer, Object[] values, ConstantPoolVisitor visitor) throws InvalidConstantPoolFormatException {
195 for (int i = 1; i < tags.length; ) {
196 byte tag = (byte) getUnsignedByte(buffer);
197 assert(tags[i] == 0 || tags[i] == tag);
198 tags[i] = tag;
199 switch (tag) {
200 case CONSTANT_Utf8:
201 int utfLen = getUnsignedShort(buffer);
202 String value = getUTF8(buffer, utfLen, getCharArray(utfLen));
203 visitor.visitUTF8(i, CONSTANT_Utf8, value);
204 tags[i] = tag;
205 values[i++] = value;
206 break;
207 case CONSTANT_Integer:
208 visitor.visitConstantValue(i, tag, buffer.getInt());
209 i++;
210 break;
211 case CONSTANT_Float:
212 visitor.visitConstantValue(i, tag, buffer.getFloat());
213 i++;
214 break;
215 case CONSTANT_Long:
216 visitor.visitConstantValue(i, tag, buffer.getLong());
217 i+=2;
218 break;
219 case CONSTANT_Double:
220 visitor.visitConstantValue(i, tag, buffer.getDouble());
221 i+=2;
222 break;
223
224 case CONSTANT_Class: // fall through:
225 case CONSTANT_String:
226 tags[i] = tag;
227 values[i++] = new int[] { getUnsignedShort(buffer) };
228 break;
229
230 case CONSTANT_Fieldref: // fall through:
231 case CONSTANT_Methodref: // fall through:
232 case CONSTANT_InterfaceMethodref: // fall through:
233 case CONSTANT_NameAndType:
234 tags[i] = tag;
235 values[i++] = new int[] { getUnsignedShort(buffer), getUnsignedShort(buffer) };
236 break;
237 default:
238 throw new AssertionError("invalid constant "+tag);
239 }
240 }
241 }
242
243 private void resolveConstantPool(Object[] values, ConstantPoolVisitor visitor) {
244 // clean out the int[] values, which are temporary
245 for (int beg = 1, end = values.length-1, beg2, end2;
246 beg <= end;
247 beg = beg2, end = end2) {
248 beg2 = end; end2 = beg-1;
249 //System.out.println("CP resolve pass: "+beg+".."+end);
250 for (int i = beg; i <= end; i++) {
251 Object value = values[i];
252 if (!(value instanceof int[]))
253 continue;
254 int[] array = (int[]) value;
255 byte tag = tags[i];
256 switch (tag) {
257 case CONSTANT_String:
258 String stringBody = (String) values[array[0]];
259 visitor.visitConstantString(i, tag, stringBody, array[0]);
260 values[i] = null;
261 break;
262 case CONSTANT_Class: {
263 String className = (String) values[array[0]];
264 // use the external form favored by Class.forName:
265 className = className.replace('/', '.');
266 visitor.visitConstantString(i, tag, className, array[0]);
267 values[i] = className;
268 break;
269 }
270 case CONSTANT_NameAndType: {
271 String memberName = (String) values[array[0]];
272 String signature = (String) values[array[1]];
273 visitor.visitDescriptor(i, tag, memberName, signature,
274 array[0], array[1]);
275 values[i] = new String[] {memberName, signature};
276 break;
277 }
278 case CONSTANT_Fieldref: // fall through:
279 case CONSTANT_Methodref: // fall through:
280 case CONSTANT_InterfaceMethodref: {
281 Object className = values[array[0]];
282 Object nameAndType = values[array[1]];
283 if (!(className instanceof String) ||
284 !(nameAndType instanceof String[])) {
285 // one more pass is needed
286 if (beg2 > i) beg2 = i;
287 if (end2 < i) end2 = i;
288 continue;
289 }
290 String[] nameAndTypeArray = (String[]) nameAndType;
291 visitor.visitMemberRef(i, tag,
292 (String)className,
293 nameAndTypeArray[0],
294 nameAndTypeArray[1],
295 array[0], array[1]);
296 values[i] = null;
297 }
298 break;
299 default:
300 continue;
301 }
302 }
303 }
304 }
305
306 private static int getUnsignedByte(ByteBuffer buffer) {
307 return buffer.get() & 0xFF;
308 }
309
310 private static int getUnsignedShort(ByteBuffer buffer) {
311 int b1 = getUnsignedByte(buffer);
312 int b2 = getUnsignedByte(buffer);
313 return (b1 << 8) + (b2 << 0);
314 }
315
316 private static String getUTF8(ByteBuffer buffer, int utfLen, char[] charArray) throws InvalidConstantPoolFormatException {
317 int utfLimit = buffer.position() + utfLen;
318 int index = 0;
319 while (buffer.position() < utfLimit) {
320 int c = buffer.get() & 0xff;
321 if (c > 127) {
322 buffer.position(buffer.position() - 1);
323 return getUTF8Extended(buffer, utfLimit, charArray, index);
324 }
325 charArray[index++] = (char)c;
326 }
327 return new String(charArray, 0, index);
328 }
329
330 private static String getUTF8Extended(ByteBuffer buffer, int utfLimit, char[] charArray, int index) throws InvalidConstantPoolFormatException {
331 int c, c2, c3;
332 while (buffer.position() < utfLimit) {
333 c = buffer.get() & 0xff;
334 switch (c >> 4) {
335 case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
336 /* 0xxxxxxx*/
337 charArray[index++] = (char)c;
338 break;
339 case 12: case 13:
340 /* 110x xxxx 10xx xxxx*/
341 c2 = buffer.get();
342 if ((c2 & 0xC0) != 0x80)
343 throw new InvalidConstantPoolFormatException(
344 "malformed input around byte " + buffer.position());
345 charArray[index++] = (char)(((c & 0x1F) << 6) |
346 (c2 & 0x3F));
347 break;
348 case 14:
349 /* 1110 xxxx 10xx xxxx 10xx xxxx */
350 c2 = buffer.get();
351 c3 = buffer.get();
352 if (((c2 & 0xC0) != 0x80) || ((c3 & 0xC0) != 0x80))
353 throw new InvalidConstantPoolFormatException(
354 "malformed input around byte " + (buffer.position()));
355 charArray[index++] = (char)(((c & 0x0F) << 12) |
356 ((c2 & 0x3F) << 6) |
357 ((c3 & 0x3F) << 0));
358 break;
359 default:
360 /* 10xx xxxx, 1111 xxxx */
361 throw new InvalidConstantPoolFormatException(
362 "malformed input around byte " + buffer.position());
363 }
364 }
365 // The number of chars produced may be less than utflen
366 return new String(charArray, 0, index);
367 }
368}