1 /*
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This code is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 only, as
6 * published by the Free Software Foundation. Oracle designates this
7 * particular file as subject to the "Classpath" exception as provided
8 * by Oracle in the LICENSE file that accompanied this code.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 */
24
25 /*
26 * This file is available under and governed by the GNU General Public
27 * License version 2 only, as published by the Free Software Foundation.
28 * However, the following notice accompanied the original version of this
29 * file:
30 *
31 * ASM: a very small and fast Java bytecode manipulation framework
32 * Copyright (c) 2000-2011 INRIA, France Telecom
33 * All rights reserved.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 * 3. Neither the name of the copyright holders nor the names of its
44 * contributors may be used to endorse or promote products derived from
45 * this software without specific prior written permission.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
48 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
51 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
52 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
53 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
54 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
55 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
56 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
57 * THE POSSIBILITY OF SUCH DAMAGE.
58 */
59 package jdk.internal.org.objectweb.asm;
60
61 /**
62 * A {@link ClassVisitor} that generates classes in bytecode form. More
63 * precisely this visitor generates a byte array conforming to the Java class
64 * file format. It can be used alone, to generate a Java class "from scratch",
65 * or with one or more {@link ClassReader ClassReader} and adapter class visitor
66 * to generate a modified class from one or more existing Java classes.
67 *
68 * @author Eric Bruneton
69 */
70 public class ClassWriter extends ClassVisitor {
71
72 /**
73 * Flag to automatically compute the maximum stack size and the maximum
74 * number of local variables of methods. If this flag is set, then the
75 * arguments of the {@link MethodVisitor#visitMaxs visitMaxs} method of the
76 * {@link MethodVisitor} returned by the {@link #visitMethod visitMethod}
77 * method will be ignored, and computed automatically from the signature and
78 * the bytecode of each method.
79 *
80 * @see #ClassWriter(int)
81 */
82 public static final int COMPUTE_MAXS = 1;
83
84 /**
85 * Flag to automatically compute the stack map frames of methods from
86 * scratch. If this flag is set, then the calls to the
87 * {@link MethodVisitor#visitFrame} method are ignored, and the stack map
88 * frames are recomputed from the methods bytecode. The arguments of the
89 * {@link MethodVisitor#visitMaxs visitMaxs} method are also ignored and
90 * recomputed from the bytecode. In other words, computeFrames implies
91 * computeMaxs.
92 *
93 * @see #ClassWriter(int)
94 */
95 public static final int COMPUTE_FRAMES = 2;
96
97 /**
98 * Pseudo access flag to distinguish between the synthetic attribute and the
99 * synthetic access flag.
100 */
101 static final int ACC_SYNTHETIC_ATTRIBUTE = 0x40000;
102
103 /**
104 * Factor to convert from ACC_SYNTHETIC_ATTRIBUTE to Opcode.ACC_SYNTHETIC.
105 */
106 static final int TO_ACC_SYNTHETIC = ACC_SYNTHETIC_ATTRIBUTE
107 / Opcodes.ACC_SYNTHETIC;
108
109 /**
110 * The type of instructions without any argument.
111 */
112 static final int NOARG_INSN = 0;
113
114 /**
115 * The type of instructions with an signed byte argument.
116 */
117 static final int SBYTE_INSN = 1;
118
119 /**
120 * The type of instructions with an signed short argument.
121 */
122 static final int SHORT_INSN = 2;
123
124 /**
125 * The type of instructions with a local variable index argument.
126 */
127 static final int VAR_INSN = 3;
128
129 /**
130 * The type of instructions with an implicit local variable index argument.
131 */
132 static final int IMPLVAR_INSN = 4;
133
134 /**
135 * The type of instructions with a type descriptor argument.
136 */
137 static final int TYPE_INSN = 5;
138
139 /**
140 * The type of field and method invocations instructions.
141 */
142 static final int FIELDORMETH_INSN = 6;
143
144 /**
145 * The type of the INVOKEINTERFACE/INVOKEDYNAMIC instruction.
146 */
147 static final int ITFMETH_INSN = 7;
148
149 /**
150 * The type of the INVOKEDYNAMIC instruction.
151 */
152 static final int INDYMETH_INSN = 8;
153
154 /**
155 * The type of instructions with a 2 bytes bytecode offset label.
156 */
157 static final int LABEL_INSN = 9;
158
159 /**
160 * The type of instructions with a 4 bytes bytecode offset label.
161 */
162 static final int LABELW_INSN = 10;
163
164 /**
165 * The type of the LDC instruction.
166 */
167 static final int LDC_INSN = 11;
168
169 /**
170 * The type of the LDC_W and LDC2_W instructions.
171 */
172 static final int LDCW_INSN = 12;
173
174 /**
175 * The type of the IINC instruction.
176 */
177 static final int IINC_INSN = 13;
178
179 /**
180 * The type of the TABLESWITCH instruction.
181 */
182 static final int TABL_INSN = 14;
183
184 /**
185 * The type of the LOOKUPSWITCH instruction.
186 */
187 static final int LOOK_INSN = 15;
188
189 /**
190 * The type of the MULTIANEWARRAY instruction.
191 */
192 static final int MANA_INSN = 16;
193
194 /**
195 * The type of the WIDE instruction.
196 */
197 static final int WIDE_INSN = 17;
198
199 /**
200 * The instruction types of all JVM opcodes.
201 */
202 static final byte[] TYPE;
203
204 /**
205 * The type of CONSTANT_Class constant pool items.
206 */
207 static final int CLASS = 7;
208
209 /**
210 * The type of CONSTANT_Fieldref constant pool items.
211 */
212 static final int FIELD = 9;
213
214 /**
215 * The type of CONSTANT_Methodref constant pool items.
216 */
217 static final int METH = 10;
218
219 /**
220 * The type of CONSTANT_InterfaceMethodref constant pool items.
221 */
222 static final int IMETH = 11;
223
224 /**
225 * The type of CONSTANT_String constant pool items.
226 */
227 static final int STR = 8;
228
229 /**
230 * The type of CONSTANT_Integer constant pool items.
231 */
232 static final int INT = 3;
233
234 /**
235 * The type of CONSTANT_Float constant pool items.
236 */
237 static final int FLOAT = 4;
238
239 /**
240 * The type of CONSTANT_Long constant pool items.
241 */
242 static final int LONG = 5;
243
244 /**
245 * The type of CONSTANT_Double constant pool items.
246 */
247 static final int DOUBLE = 6;
248
249 /**
250 * The type of CONSTANT_NameAndType constant pool items.
251 */
252 static final int NAME_TYPE = 12;
253
254 /**
255 * The type of CONSTANT_Utf8 constant pool items.
256 */
257 static final int UTF8 = 1;
258
259 /**
260 * The type of CONSTANT_MethodType constant pool items.
261 */
262 static final int MTYPE = 16;
263
264 /**
265 * The type of CONSTANT_MethodHandle constant pool items.
266 */
267 static final int HANDLE = 15;
268
269 /**
270 * The type of CONSTANT_InvokeDynamic constant pool items.
271 */
272 static final int INDY = 18;
273
274 /**
275 * The base value for all CONSTANT_MethodHandle constant pool items.
276 * Internally, ASM store the 9 variations of CONSTANT_MethodHandle into 9
277 * different items.
278 */
279 static final int HANDLE_BASE = 20;
280
281 /**
282 * Normal type Item stored in the ClassWriter {@link ClassWriter#typeTable},
283 * instead of the constant pool, in order to avoid clashes with normal
284 * constant pool items in the ClassWriter constant pool's hash table.
285 */
286 static final int TYPE_NORMAL = 30;
287
288 /**
289 * Uninitialized type Item stored in the ClassWriter
290 * {@link ClassWriter#typeTable}, instead of the constant pool, in order to
291 * avoid clashes with normal constant pool items in the ClassWriter constant
292 * pool's hash table.
293 */
294 static final int TYPE_UNINIT = 31;
295
296 /**
297 * Merged type Item stored in the ClassWriter {@link ClassWriter#typeTable},
298 * instead of the constant pool, in order to avoid clashes with normal
299 * constant pool items in the ClassWriter constant pool's hash table.
300 */
301 static final int TYPE_MERGED = 32;
302
303 /**
304 * The type of BootstrapMethods items. These items are stored in a special
305 * class attribute named BootstrapMethods and not in the constant pool.
306 */
307 static final int BSM = 33;
308
309 /**
310 * The class reader from which this class writer was constructed, if any.
311 */
312 ClassReader cr;
313
314 /**
315 * Minor and major version numbers of the class to be generated.
316 */
317 int version;
318
319 /**
320 * Index of the next item to be added in the constant pool.
321 */
322 int index;
323
324 /**
325 * The constant pool of this class.
326 */
327 final ByteVector pool;
328
329 /**
330 * The constant pool's hash table data.
331 */
332 Item[] items;
333
334 /**
335 * The threshold of the constant pool's hash table.
336 */
337 int threshold;
338
339 /**
340 * A reusable key used to look for items in the {@link #items} hash table.
341 */
342 final Item key;
343
344 /**
345 * A reusable key used to look for items in the {@link #items} hash table.
346 */
347 final Item key2;
348
349 /**
350 * A reusable key used to look for items in the {@link #items} hash table.
351 */
352 final Item key3;
353
354 /**
355 * A reusable key used to look for items in the {@link #items} hash table.
356 */
357 final Item key4;
358
359 /**
360 * A type table used to temporarily store internal names that will not
361 * necessarily be stored in the constant pool. This type table is used by
362 * the control flow and data flow analysis algorithm used to compute stack
363 * map frames from scratch. This array associates to each index <tt>i</tt>
364 * the Item whose index is <tt>i</tt>. All Item objects stored in this array
365 * are also stored in the {@link #items} hash table. These two arrays allow
366 * to retrieve an Item from its index or, conversely, to get the index of an
367 * Item from its value. Each Item stores an internal name in its
368 * {@link Item#strVal1} field.
369 */
370 Item[] typeTable;
371
372 /**
373 * Number of elements in the {@link #typeTable} array.
374 */
375 private short typeCount;
376
377 /**
378 * The access flags of this class.
379 */
380 private int access;
381
382 /**
383 * The constant pool item that contains the internal name of this class.
384 */
385 private int name;
386
387 /**
388 * The internal name of this class.
389 */
390 String thisName;
391
392 /**
393 * The constant pool item that contains the signature of this class.
394 */
395 private int signature;
396
397 /**
398 * The constant pool item that contains the internal name of the super class
399 * of this class.
400 */
401 private int superName;
402
403 /**
404 * Number of interfaces implemented or extended by this class or interface.
405 */
406 private int interfaceCount;
407
408 /**
409 * The interfaces implemented or extended by this class or interface. More
410 * precisely, this array contains the indexes of the constant pool items
411 * that contain the internal names of these interfaces.
412 */
413 private int[] interfaces;
414
415 /**
416 * The index of the constant pool item that contains the name of the source
417 * file from which this class was compiled.
418 */
419 private int sourceFile;
420
421 /**
422 * The SourceDebug attribute of this class.
423 */
424 private ByteVector sourceDebug;
425
426 /**
427 * The constant pool item that contains the name of the enclosing class of
428 * this class.
429 */
430 private int enclosingMethodOwner;
431
432 /**
433 * The constant pool item that contains the name and descriptor of the
434 * enclosing method of this class.
435 */
436 private int enclosingMethod;
437
438 /**
439 * The runtime visible annotations of this class.
440 */
441 private AnnotationWriter anns;
442
443 /**
444 * The runtime invisible annotations of this class.
445 */
446 private AnnotationWriter ianns;
447
448 /**
449 * The runtime visible type annotations of this class.
450 */
451 private AnnotationWriter tanns;
452
453 /**
454 * The runtime invisible type annotations of this class.
455 */
456 private AnnotationWriter itanns;
457
458 /**
459 * The non standard attributes of this class.
460 */
461 private Attribute attrs;
462
463 /**
464 * The number of entries in the InnerClasses attribute.
465 */
466 private int innerClassesCount;
467
468 /**
469 * The InnerClasses attribute.
470 */
471 private ByteVector innerClasses;
472
473 /**
474 * The number of entries in the BootstrapMethods attribute.
475 */
476 int bootstrapMethodsCount;
477
478 /**
479 * The BootstrapMethods attribute.
480 */
481 ByteVector bootstrapMethods;
482
483 /**
484 * The fields of this class. These fields are stored in a linked list of
485 * {@link FieldWriter} objects, linked to each other by their
486 * {@link FieldWriter#fv} field. This field stores the first element of this
487 * list.
488 */
489 FieldWriter firstField;
490
491 /**
492 * The fields of this class. These fields are stored in a linked list of
493 * {@link FieldWriter} objects, linked to each other by their
494 * {@link FieldWriter#fv} field. This field stores the last element of this
495 * list.
496 */
497 FieldWriter lastField;
498
499 /**
500 * The methods of this class. These methods are stored in a linked list of
501 * {@link MethodWriter} objects, linked to each other by their
502 * {@link MethodWriter#mv} field. This field stores the first element of
503 * this list.
504 */
505 MethodWriter firstMethod;
506
507 /**
508 * The methods of this class. These methods are stored in a linked list of
509 * {@link MethodWriter} objects, linked to each other by their
510 * {@link MethodWriter#mv} field. This field stores the last element of this
511 * list.
512 */
513 MethodWriter lastMethod;
514
515 /**
516 * <tt>true</tt> if the maximum stack size and number of local variables
517 * must be automatically computed.
518 */
519 private boolean computeMaxs;
520
521 /**
522 * <tt>true</tt> if the stack map frames must be recomputed from scratch.
523 */
524 private boolean computeFrames;
525
526 /**
527 * <tt>true</tt> if the stack map tables of this class are invalid. The
528 * {@link MethodWriter#resizeInstructions} method cannot transform existing
529 * stack map tables, and so produces potentially invalid classes when it is
530 * executed. In this case the class is reread and rewritten with the
531 * {@link #COMPUTE_FRAMES} option (the resizeInstructions method can resize
532 * stack map tables when this option is used).
533 */
534 boolean invalidFrames;
535
536 // ------------------------------------------------------------------------
537 // Static initializer
538 // ------------------------------------------------------------------------
539
540 /**
541 * Computes the instruction types of JVM opcodes.
542 */
543 static {
544 int i;
545 byte[] b = new byte[220];
546 String s = "AAAAAAAAAAAAAAAABCLMMDDDDDEEEEEEEEEEEEEEEEEEEEAAAAAAAADD"
547 + "DDDEEEEEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
548 + "AAAAAAAAAAAAAAAAANAAAAAAAAAAAAAAAAAAAAJJJJJJJJJJJJJJJJDOPAA"
549 + "AAAAGGGGGGGHIFBFAAFFAARQJJKKJJJJJJJJJJJJJJJJJJ";
550 for (i = 0; i < b.length; ++i) {
551 b[i] = (byte) (s.charAt(i) - 'A');
552 }
553 TYPE = b;
554
555 // code to generate the above string
556 //
557 // // SBYTE_INSN instructions
558 // b[Constants.NEWARRAY] = SBYTE_INSN;
559 // b[Constants.BIPUSH] = SBYTE_INSN;
560 //
561 // // SHORT_INSN instructions
562 // b[Constants.SIPUSH] = SHORT_INSN;
563 //
564 // // (IMPL)VAR_INSN instructions
565 // b[Constants.RET] = VAR_INSN;
566 // for (i = Constants.ILOAD; i <= Constants.ALOAD; ++i) {
567 // b[i] = VAR_INSN;
568 // }
569 // for (i = Constants.ISTORE; i <= Constants.ASTORE; ++i) {
570 // b[i] = VAR_INSN;
571 // }
572 // for (i = 26; i <= 45; ++i) { // ILOAD_0 to ALOAD_3
573 // b[i] = IMPLVAR_INSN;
574 // }
575 // for (i = 59; i <= 78; ++i) { // ISTORE_0 to ASTORE_3
576 // b[i] = IMPLVAR_INSN;
577 // }
578 //
579 // // TYPE_INSN instructions
580 // b[Constants.NEW] = TYPE_INSN;
581 // b[Constants.ANEWARRAY] = TYPE_INSN;
582 // b[Constants.CHECKCAST] = TYPE_INSN;
583 // b[Constants.INSTANCEOF] = TYPE_INSN;
584 //
585 // // (Set)FIELDORMETH_INSN instructions
586 // for (i = Constants.GETSTATIC; i <= Constants.INVOKESTATIC; ++i) {
587 // b[i] = FIELDORMETH_INSN;
588 // }
589 // b[Constants.INVOKEINTERFACE] = ITFMETH_INSN;
590 // b[Constants.INVOKEDYNAMIC] = INDYMETH_INSN;
591 //
592 // // LABEL(W)_INSN instructions
593 // for (i = Constants.IFEQ; i <= Constants.JSR; ++i) {
594 // b[i] = LABEL_INSN;
595 // }
596 // b[Constants.IFNULL] = LABEL_INSN;
597 // b[Constants.IFNONNULL] = LABEL_INSN;
598 // b[200] = LABELW_INSN; // GOTO_W
599 // b[201] = LABELW_INSN; // JSR_W
600 // // temporary opcodes used internally by ASM - see Label and
601 // MethodWriter
602 // for (i = 202; i < 220; ++i) {
603 // b[i] = LABEL_INSN;
604 // }
605 //
606 // // LDC(_W) instructions
607 // b[Constants.LDC] = LDC_INSN;
608 // b[19] = LDCW_INSN; // LDC_W
609 // b[20] = LDCW_INSN; // LDC2_W
610 //
611 // // special instructions
612 // b[Constants.IINC] = IINC_INSN;
613 // b[Constants.TABLESWITCH] = TABL_INSN;
614 // b[Constants.LOOKUPSWITCH] = LOOK_INSN;
615 // b[Constants.MULTIANEWARRAY] = MANA_INSN;
616 // b[196] = WIDE_INSN; // WIDE
617 //
618 // for (i = 0; i < b.length; ++i) {
619 // System.err.print((char)('A' + b[i]));
620 // }
621 // System.err.println();
622 }
623
624 // ------------------------------------------------------------------------
625 // Constructor
626 // ------------------------------------------------------------------------
627
628 /**
629 * Constructs a new {@link ClassWriter} object.
630 *
631 * @param flags
632 * option flags that can be used to modify the default behavior
633 * of this class. See {@link #COMPUTE_MAXS},
634 * {@link #COMPUTE_FRAMES}.
635 */
636 public ClassWriter(final int flags) {
637 super(Opcodes.ASM5);
638 index = 1;
639 pool = new ByteVector();
640 items = new Item[256];
641 threshold = (int) (0.75d * items.length);
642 key = new Item();
643 key2 = new Item();
644 key3 = new Item();
645 key4 = new Item();
646 this.computeMaxs = (flags & COMPUTE_MAXS) != 0;
647 this.computeFrames = (flags & COMPUTE_FRAMES) != 0;
648 }
649
650 /**
651 * Constructs a new {@link ClassWriter} object and enables optimizations for
652 * "mostly add" bytecode transformations. These optimizations are the
653 * following:
654 *
655 * <ul>
656 * <li>The constant pool from the original class is copied as is in the new
657 * class, which saves time. New constant pool entries will be added at the
658 * end if necessary, but unused constant pool entries <i>won't be
659 * removed</i>.</li>
660 * <li>Methods that are not transformed are copied as is in the new class,
661 * directly from the original class bytecode (i.e. without emitting visit
662 * events for all the method instructions), which saves a <i>lot</i> of
663 * time. Untransformed methods are detected by the fact that the
664 * {@link ClassReader} receives {@link MethodVisitor} objects that come from
665 * a {@link ClassWriter} (and not from any other {@link ClassVisitor}
666 * instance).</li>
667 * </ul>
668 *
669 * @param classReader
670 * the {@link ClassReader} used to read the original class. It
671 * will be used to copy the entire constant pool from the
672 * original class and also to copy other fragments of original
673 * bytecode where applicable.
674 * @param flags
675 * option flags that can be used to modify the default behavior
676 * of this class. <i>These option flags do not affect methods
677 * that are copied as is in the new class. This means that the
678 * maximum stack size nor the stack frames will be computed for
679 * these methods</i>. See {@link #COMPUTE_MAXS},
680 * {@link #COMPUTE_FRAMES}.
681 */
682 public ClassWriter(final ClassReader classReader, final int flags) {
683 this(flags);
684 classReader.copyPool(this);
685 this.cr = classReader;
686 }
687
688 // ------------------------------------------------------------------------
689 // Implementation of the ClassVisitor abstract class
690 // ------------------------------------------------------------------------
691
692 @Override
693 public final void visit(final int version, final int access,
694 final String name, final String signature, final String superName,
695 final String[] interfaces) {
696 this.version = version;
697 this.access = access;
698 this.name = newClass(name);
699 thisName = name;
700 if (ClassReader.SIGNATURES && signature != null) {
701 this.signature = newUTF8(signature);
702 }
703 this.superName = superName == null ? 0 : newClass(superName);
704 if (interfaces != null && interfaces.length > 0) {
705 interfaceCount = interfaces.length;
706 this.interfaces = new int[interfaceCount];
707 for (int i = 0; i < interfaceCount; ++i) {
708 this.interfaces[i] = newClass(interfaces[i]);
709 }
710 }
711 }
712
713 @Override
714 public final void visitSource(final String file, final String debug) {
715 if (file != null) {
716 sourceFile = newUTF8(file);
717 }
718 if (debug != null) {
719 sourceDebug = new ByteVector().encodeUTF8(debug, 0,
720 Integer.MAX_VALUE);
721 }
722 }
723
724 @Override
725 public final void visitOuterClass(final String owner, final String name,
726 final String desc) {
727 enclosingMethodOwner = newClass(owner);
728 if (name != null && desc != null) {
729 enclosingMethod = newNameType(name, desc);
730 }
731 }
732
733 @Override
734 public final AnnotationVisitor visitAnnotation(final String desc,
735 final boolean visible) {
736 if (!ClassReader.ANNOTATIONS) {
737 return null;
738 }
739 ByteVector bv = new ByteVector();
740 // write type, and reserve space for values count
741 bv.putShort(newUTF8(desc)).putShort(0);
742 AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv, 2);
743 if (visible) {
744 aw.next = anns;
745 anns = aw;
746 } else {
747 aw.next = ianns;
748 ianns = aw;
749 }
750 return aw;
751 }
752
753 @Override
754 public final AnnotationVisitor visitTypeAnnotation(int typeRef,
755 TypePath typePath, final String desc, final boolean visible) {
756 if (!ClassReader.ANNOTATIONS) {
757 return null;
758 }
759 ByteVector bv = new ByteVector();
760 // write target_type and target_info
761 AnnotationWriter.putTarget(typeRef, typePath, bv);
762 // write type, and reserve space for values count
763 bv.putShort(newUTF8(desc)).putShort(0);
764 AnnotationWriter aw = new AnnotationWriter(this, true, bv, bv,
765 bv.length - 2);
766 if (visible) {
767 aw.next = tanns;
768 tanns = aw;
769 } else {
770 aw.next = itanns;
771 itanns = aw;
772 }
773 return aw;
774 }
775
776 @Override
777 public final void visitAttribute(final Attribute attr) {
778 attr.next = attrs;
779 attrs = attr;
780 }
781
782 @Override
783 public final void visitInnerClass(final String name,
784 final String outerName, final String innerName, final int access) {
785 if (innerClasses == null) {
786 innerClasses = new ByteVector();
787 }
788 // Sec. 4.7.6 of the JVMS states "Every CONSTANT_Class_info entry in the
789 // constant_pool table which represents a class or interface C that is
790 // not a package member must have exactly one corresponding entry in the
791 // classes array". To avoid duplicates we keep track in the intVal field
792 // of the Item of each CONSTANT_Class_info entry C whether an inner
793 // class entry has already been added for C (this field is unused for
794 // class entries, and changing its value does not change the hashcode
795 // and equality tests). If so we store the index of this inner class
796 // entry (plus one) in intVal. This hack allows duplicate detection in
797 // O(1) time.
798 Item nameItem = newClassItem(name);
799 if (nameItem.intVal == 0) {
800 ++innerClassesCount;
801 innerClasses.putShort(nameItem.index);
802 innerClasses.putShort(outerName == null ? 0 : newClass(outerName));
803 innerClasses.putShort(innerName == null ? 0 : newUTF8(innerName));
804 innerClasses.putShort(access);
805 nameItem.intVal = innerClassesCount;
806 } else {
807 // Compare the inner classes entry nameItem.intVal - 1 with the
808 // arguments of this method and throw an exception if there is a
809 // difference?
810 }
811 }
812
813 @Override
814 public final FieldVisitor visitField(final int access, final String name,
815 final String desc, final String signature, final Object value) {
816 return new FieldWriter(this, access, name, desc, signature, value);
817 }
818
819 @Override
820 public final MethodVisitor visitMethod(final int access, final String name,
821 final String desc, final String signature, final String[] exceptions) {
822 return new MethodWriter(this, access, name, desc, signature,
823 exceptions, computeMaxs, computeFrames);
824 }
825
826 @Override
827 public final void visitEnd() {
828 }
829
830 // ------------------------------------------------------------------------
831 // Other public methods
832 // ------------------------------------------------------------------------
833
834 /**
835 * Returns the bytecode of the class that was build with this class writer.
836 *
837 * @return the bytecode of the class that was build with this class writer.
838 */
839 public byte[] toByteArray() {
840 if (index > 0xFFFF) {
841 throw new RuntimeException("Class file too large!");
842 }
843 // computes the real size of the bytecode of this class
844 int size = 24 + 2 * interfaceCount;
845 int nbFields = 0;
846 FieldWriter fb = firstField;
847 while (fb != null) {
848 ++nbFields;
849 size += fb.getSize();
850 fb = (FieldWriter) fb.fv;
851 }
852 int nbMethods = 0;
853 MethodWriter mb = firstMethod;
854 while (mb != null) {
855 ++nbMethods;
856 size += mb.getSize();
857 mb = (MethodWriter) mb.mv;
858 }
859 int attributeCount = 0;
860 if (bootstrapMethods != null) {
861 // we put it as first attribute in order to improve a bit
862 // ClassReader.copyBootstrapMethods
863 ++attributeCount;
864 size += 8 + bootstrapMethods.length;
865 newUTF8("BootstrapMethods");
866 }
867 if (ClassReader.SIGNATURES && signature != 0) {
868 ++attributeCount;
869 size += 8;
870 newUTF8("Signature");
871 }
872 if (sourceFile != 0) {
873 ++attributeCount;
874 size += 8;
875 newUTF8("SourceFile");
876 }
877 if (sourceDebug != null) {
878 ++attributeCount;
879 size += sourceDebug.length + 6;
880 newUTF8("SourceDebugExtension");
881 }
882 if (enclosingMethodOwner != 0) {
883 ++attributeCount;
884 size += 10;
885 newUTF8("EnclosingMethod");
886 }
887 if ((access & Opcodes.ACC_DEPRECATED) != 0) {
888 ++attributeCount;
889 size += 6;
890 newUTF8("Deprecated");
891 }
892 if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
893 if ((version & 0xFFFF) < Opcodes.V1_5
894 || (access & ACC_SYNTHETIC_ATTRIBUTE) != 0) {
895 ++attributeCount;
896 size += 6;
897 newUTF8("Synthetic");
898 }
899 }
900 if (innerClasses != null) {
901 ++attributeCount;
902 size += 8 + innerClasses.length;
903 newUTF8("InnerClasses");
904 }
905 if (ClassReader.ANNOTATIONS && anns != null) {
906 ++attributeCount;
907 size += 8 + anns.getSize();
908 newUTF8("RuntimeVisibleAnnotations");
909 }
910 if (ClassReader.ANNOTATIONS && ianns != null) {
911 ++attributeCount;
912 size += 8 + ianns.getSize();
913 newUTF8("RuntimeInvisibleAnnotations");
914 }
915 if (ClassReader.ANNOTATIONS && tanns != null) {
916 ++attributeCount;
917 size += 8 + tanns.getSize();
918 newUTF8("RuntimeVisibleTypeAnnotations");
919 }
920 if (ClassReader.ANNOTATIONS && itanns != null) {
921 ++attributeCount;
922 size += 8 + itanns.getSize();
923 newUTF8("RuntimeInvisibleTypeAnnotations");
924 }
925 if (attrs != null) {
926 attributeCount += attrs.getCount();
927 size += attrs.getSize(this, null, 0, -1, -1);
928 }
929 size += pool.length;
930 // allocates a byte vector of this size, in order to avoid unnecessary
931 // arraycopy operations in the ByteVector.enlarge() method
932 ByteVector out = new ByteVector(size);
933 out.putInt(0xCAFEBABE).putInt(version);
934 out.putShort(index).putByteArray(pool.data, 0, pool.length);
935 int mask = Opcodes.ACC_DEPRECATED | ACC_SYNTHETIC_ATTRIBUTE
936 | ((access & ACC_SYNTHETIC_ATTRIBUTE) / TO_ACC_SYNTHETIC);
937 out.putShort(access & ~mask).putShort(name).putShort(superName);
938 out.putShort(interfaceCount);
939 for (int i = 0; i < interfaceCount; ++i) {
940 out.putShort(interfaces[i]);
941 }
942 out.putShort(nbFields);
943 fb = firstField;
944 while (fb != null) {
945 fb.put(out);
946 fb = (FieldWriter) fb.fv;
947 }
948 out.putShort(nbMethods);
949 mb = firstMethod;
950 while (mb != null) {
951 mb.put(out);
952 mb = (MethodWriter) mb.mv;
953 }
954 out.putShort(attributeCount);
955 if (bootstrapMethods != null) {
956 out.putShort(newUTF8("BootstrapMethods"));
957 out.putInt(bootstrapMethods.length + 2).putShort(
958 bootstrapMethodsCount);
959 out.putByteArray(bootstrapMethods.data, 0, bootstrapMethods.length);
960 }
961 if (ClassReader.SIGNATURES && signature != 0) {
962 out.putShort(newUTF8("Signature")).putInt(2).putShort(signature);
963 }
964 if (sourceFile != 0) {
965 out.putShort(newUTF8("SourceFile")).putInt(2).putShort(sourceFile);
966 }
967 if (sourceDebug != null) {
968 int len = sourceDebug.length;
969 out.putShort(newUTF8("SourceDebugExtension")).putInt(len);
970 out.putByteArray(sourceDebug.data, 0, len);
971 }
972 if (enclosingMethodOwner != 0) {
973 out.putShort(newUTF8("EnclosingMethod")).putInt(4);
974 out.putShort(enclosingMethodOwner).putShort(enclosingMethod);
975 }
976 if ((access & Opcodes.ACC_DEPRECATED) != 0) {
977 out.putShort(newUTF8("Deprecated")).putInt(0);
978 }
979 if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
980 if ((version & 0xFFFF) < Opcodes.V1_5
981 || (access & ACC_SYNTHETIC_ATTRIBUTE) != 0) {
982 out.putShort(newUTF8("Synthetic")).putInt(0);
983 }
984 }
985 if (innerClasses != null) {
986 out.putShort(newUTF8("InnerClasses"));
987 out.putInt(innerClasses.length + 2).putShort(innerClassesCount);
988 out.putByteArray(innerClasses.data, 0, innerClasses.length);
989 }
990 if (ClassReader.ANNOTATIONS && anns != null) {
991 out.putShort(newUTF8("RuntimeVisibleAnnotations"));
992 anns.put(out);
993 }
994 if (ClassReader.ANNOTATIONS && ianns != null) {
995 out.putShort(newUTF8("RuntimeInvisibleAnnotations"));
996 ianns.put(out);
997 }
998 if (ClassReader.ANNOTATIONS && tanns != null) {
999 out.putShort(newUTF8("RuntimeVisibleTypeAnnotations"));
1000 tanns.put(out);
1001 }
1002 if (ClassReader.ANNOTATIONS && itanns != null) {
1003 out.putShort(newUTF8("RuntimeInvisibleTypeAnnotations"));
1004 itanns.put(out);
1005 }
1006 if (attrs != null) {
1007 attrs.put(this, null, 0, -1, -1, out);
1008 }
1009 if (invalidFrames) {
1010 anns = null;
1011 ianns = null;
1012 attrs = null;
1013 innerClassesCount = 0;
1014 innerClasses = null;
1015 bootstrapMethodsCount = 0;
1016 bootstrapMethods = null;
1017 firstField = null;
1018 lastField = null;
1019 firstMethod = null;
1020 lastMethod = null;
1021 computeMaxs = false;
1022 computeFrames = true;
1023 invalidFrames = false;
1024 new ClassReader(out.data).accept(this, ClassReader.SKIP_FRAMES);
1025 return toByteArray();
1026 }
1027 return out.data;
1028 }
1029
1030 // ------------------------------------------------------------------------
1031 // Utility methods: constant pool management
1032 // ------------------------------------------------------------------------
1033
1034 /**
1035 * Adds a number or string constant to the constant pool of the class being
1036 * build. Does nothing if the constant pool already contains a similar item.
1037 *
1038 * @param cst
1039 * the value of the constant to be added to the constant pool.
1040 * This parameter must be an {@link Integer}, a {@link Float}, a
1041 * {@link Long}, a {@link Double}, a {@link String} or a
1042 * {@link Type}.
1043 * @return a new or already existing constant item with the given value.
1044 */
1045 Item newConstItem(final Object cst) {
1046 if (cst instanceof Integer) {
1047 int val = ((Integer) cst).intValue();
1048 return newInteger(val);
1049 } else if (cst instanceof Byte) {
1050 int val = ((Byte) cst).intValue();
1051 return newInteger(val);
1052 } else if (cst instanceof Character) {
1053 int val = ((Character) cst).charValue();
1054 return newInteger(val);
1055 } else if (cst instanceof Short) {
1056 int val = ((Short) cst).intValue();
1057 return newInteger(val);
1058 } else if (cst instanceof Boolean) {
1059 int val = ((Boolean) cst).booleanValue() ? 1 : 0;
1060 return newInteger(val);
1061 } else if (cst instanceof Float) {
1062 float val = ((Float) cst).floatValue();
1063 return newFloat(val);
1064 } else if (cst instanceof Long) {
1065 long val = ((Long) cst).longValue();
1066 return newLong(val);
1067 } else if (cst instanceof Double) {
1068 double val = ((Double) cst).doubleValue();
1069 return newDouble(val);
1070 } else if (cst instanceof String) {
1071 return newString((String) cst);
1072 } else if (cst instanceof Type) {
1073 Type t = (Type) cst;
1074 int s = t.getSort();
1075 if (s == Type.OBJECT) {
1076 return newClassItem(t.getInternalName());
1077 } else if (s == Type.METHOD) {
1078 return newMethodTypeItem(t.getDescriptor());
1079 } else { // s == primitive type or array
1080 return newClassItem(t.getDescriptor());
1081 }
1082 } else if (cst instanceof Handle) {
1083 Handle h = (Handle) cst;
1084 return newHandleItem(h.tag, h.owner, h.name, h.desc);
1085 } else {
1086 throw new IllegalArgumentException("value " + cst);
1087 }
1088 }
1089
1090 /**
1091 * Adds a number or string constant to the constant pool of the class being
1092 * build. Does nothing if the constant pool already contains a similar item.
1093 * <i>This method is intended for {@link Attribute} sub classes, and is
1094 * normally not needed by class generators or adapters.</i>
1095 *
1096 * @param cst
1097 * the value of the constant to be added to the constant pool.
1098 * This parameter must be an {@link Integer}, a {@link Float}, a
1099 * {@link Long}, a {@link Double} or a {@link String}.
1100 * @return the index of a new or already existing constant item with the
1101 * given value.
1102 */
1103 public int newConst(final Object cst) {
1104 return newConstItem(cst).index;
1105 }
1106
1107 /**
1108 * Adds an UTF8 string to the constant pool of the class being build. Does
1109 * nothing if the constant pool already contains a similar item. <i>This
1110 * method is intended for {@link Attribute} sub classes, and is normally not
1111 * needed by class generators or adapters.</i>
1112 *
1113 * @param value
1114 * the String value.
1115 * @return the index of a new or already existing UTF8 item.
1116 */
1117 public int newUTF8(final String value) {
1118 key.set(UTF8, value, null, null);
1119 Item result = get(key);
1120 if (result == null) {
1121 pool.putByte(UTF8).putUTF8(value);
1122 result = new Item(index++, key);
1123 put(result);
1124 }
1125 return result.index;
1126 }
1127
1128 /**
1129 * Adds a class reference to the constant pool of the class being build.
1130 * Does nothing if the constant pool already contains a similar item.
1131 * <i>This method is intended for {@link Attribute} sub classes, and is
1132 * normally not needed by class generators or adapters.</i>
1133 *
1134 * @param value
1135 * the internal name of the class.
1136 * @return a new or already existing class reference item.
1137 */
1138 Item newClassItem(final String value) {
1139 key2.set(CLASS, value, null, null);
1140 Item result = get(key2);
1141 if (result == null) {
1142 pool.put12(CLASS, newUTF8(value));
1143 result = new Item(index++, key2);
1144 put(result);
1145 }
1146 return result;
1147 }
1148
1149 /**
1150 * Adds a class reference to the constant pool of the class being build.
1151 * Does nothing if the constant pool already contains a similar item.
1152 * <i>This method is intended for {@link Attribute} sub classes, and is
1153 * normally not needed by class generators or adapters.</i>
1154 *
1155 * @param value
1156 * the internal name of the class.
1157 * @return the index of a new or already existing class reference item.
1158 */
1159 public int newClass(final String value) {
1160 return newClassItem(value).index;
1161 }
1162
1163 /**
1164 * Adds a method type reference to the constant pool of the class being
1165 * build. Does nothing if the constant pool already contains a similar item.
1166 * <i>This method is intended for {@link Attribute} sub classes, and is
1167 * normally not needed by class generators or adapters.</i>
1168 *
1169 * @param methodDesc
1170 * method descriptor of the method type.
1171 * @return a new or already existing method type reference item.
1172 */
1173 Item newMethodTypeItem(final String methodDesc) {
1174 key2.set(MTYPE, methodDesc, null, null);
1175 Item result = get(key2);
1176 if (result == null) {
1177 pool.put12(MTYPE, newUTF8(methodDesc));
1178 result = new Item(index++, key2);
1179 put(result);
1180 }
1181 return result;
1182 }
1183
1184 /**
1185 * Adds a method type reference to the constant pool of the class being
1186 * build. Does nothing if the constant pool already contains a similar item.
1187 * <i>This method is intended for {@link Attribute} sub classes, and is
1188 * normally not needed by class generators or adapters.</i>
1189 *
1190 * @param methodDesc
1191 * method descriptor of the method type.
1192 * @return the index of a new or already existing method type reference
1193 * item.
1194 */
1195 public int newMethodType(final String methodDesc) {
1196 return newMethodTypeItem(methodDesc).index;
1197 }
1198
1199 /**
1200 * Adds a handle to the constant pool of the class being build. Does nothing
1201 * if the constant pool already contains a similar item. <i>This method is
1202 * intended for {@link Attribute} sub classes, and is normally not needed by
1203 * class generators or adapters.</i>
1204 *
1205 * @param tag
1206 * the kind of this handle. Must be {@link Opcodes#H_GETFIELD},
1207 * {@link Opcodes#H_GETSTATIC}, {@link Opcodes#H_PUTFIELD},
1208 * {@link Opcodes#H_PUTSTATIC}, {@link Opcodes#H_INVOKEVIRTUAL},
1209 * {@link Opcodes#H_INVOKESTATIC},
1210 * {@link Opcodes#H_INVOKESPECIAL},
1211 * {@link Opcodes#H_NEWINVOKESPECIAL} or
1212 * {@link Opcodes#H_INVOKEINTERFACE}.
1213 * @param owner
1214 * the internal name of the field or method owner class.
1215 * @param name
1216 * the name of the field or method.
1217 * @param desc
1218 * the descriptor of the field or method.
1219 * @return a new or an already existing method type reference item.
1220 */
1221 Item newHandleItem(final int tag, final String owner, final String name,
1222 final String desc) {
1223 key4.set(HANDLE_BASE + tag, owner, name, desc);
1224 Item result = get(key4);
1225 if (result == null) {
1226 if (tag <= Opcodes.H_PUTSTATIC) {
1227 put112(HANDLE, tag, newField(owner, name, desc));
1228 } else {
1229 put112(HANDLE,
1230 tag,
1231 newMethod(owner, name, desc,
1232 tag == Opcodes.H_INVOKEINTERFACE));
1233 }
1234 result = new Item(index++, key4);
1235 put(result);
1236 }
1237 return result;
1238 }
1239
1240 /**
1241 * Adds a handle to the constant pool of the class being build. Does nothing
1242 * if the constant pool already contains a similar item. <i>This method is
1243 * intended for {@link Attribute} sub classes, and is normally not needed by
1244 * class generators or adapters.</i>
1245 *
1246 * @param tag
1247 * the kind of this handle. Must be {@link Opcodes#H_GETFIELD},
1248 * {@link Opcodes#H_GETSTATIC}, {@link Opcodes#H_PUTFIELD},
1249 * {@link Opcodes#H_PUTSTATIC}, {@link Opcodes#H_INVOKEVIRTUAL},
1250 * {@link Opcodes#H_INVOKESTATIC},
1251 * {@link Opcodes#H_INVOKESPECIAL},
1252 * {@link Opcodes#H_NEWINVOKESPECIAL} or
1253 * {@link Opcodes#H_INVOKEINTERFACE}.
1254 * @param owner
1255 * the internal name of the field or method owner class.
1256 * @param name
1257 * the name of the field or method.
1258 * @param desc
1259 * the descriptor of the field or method.
1260 * @return the index of a new or already existing method type reference
1261 * item.
1262 */
1263 public int newHandle(final int tag, final String owner, final String name,
1264 final String desc) {
1265 return newHandleItem(tag, owner, name, desc).index;
1266 }
1267
1268 /**
1269 * Adds an invokedynamic reference to the constant pool of the class being
1270 * build. Does nothing if the constant pool already contains a similar item.
1271 * <i>This method is intended for {@link Attribute} sub classes, and is
1272 * normally not needed by class generators or adapters.</i>
1273 *
1274 * @param name
1275 * name of the invoked method.
1276 * @param desc
1277 * descriptor of the invoke method.
1278 * @param bsm
1279 * the bootstrap method.
1280 * @param bsmArgs
1281 * the bootstrap method constant arguments.
1282 *
1283 * @return a new or an already existing invokedynamic type reference item.
1284 */
1285 Item newInvokeDynamicItem(final String name, final String desc,
1286 final Handle bsm, final Object... bsmArgs) {
1287 // cache for performance
1288 ByteVector bootstrapMethods = this.bootstrapMethods;
1289 if (bootstrapMethods == null) {
1290 bootstrapMethods = this.bootstrapMethods = new ByteVector();
1291 }
1292
1293 int position = bootstrapMethods.length; // record current position
1294
1295 int hashCode = bsm.hashCode();
1296 bootstrapMethods.putShort(newHandle(bsm.tag, bsm.owner, bsm.name,
1297 bsm.desc));
1298
1299 int argsLength = bsmArgs.length;
1300 bootstrapMethods.putShort(argsLength);
1301
1302 for (int i = 0; i < argsLength; i++) {
1303 Object bsmArg = bsmArgs[i];
1304 hashCode ^= bsmArg.hashCode();
1305 bootstrapMethods.putShort(newConst(bsmArg));
1306 }
1307
1308 byte[] data = bootstrapMethods.data;
1309 int length = (1 + 1 + argsLength) << 1; // (bsm + argCount + arguments)
1310 hashCode &= 0x7FFFFFFF;
1311 Item result = items[hashCode % items.length];
1312 loop: while (result != null) {
1313 if (result.type != BSM || result.hashCode != hashCode) {
1314 result = result.next;
1315 continue;
1316 }
1317
1318 // because the data encode the size of the argument
1319 // we don't need to test if these size are equals
1320 int resultPosition = result.intVal;
1321 for (int p = 0; p < length; p++) {
1322 if (data[position + p] != data[resultPosition + p]) {
1323 result = result.next;
1324 continue loop;
1325 }
1326 }
1327 break;
1328 }
1329
1330 int bootstrapMethodIndex;
1331 if (result != null) {
1332 bootstrapMethodIndex = result.index;
1333 bootstrapMethods.length = position; // revert to old position
1334 } else {
1335 bootstrapMethodIndex = bootstrapMethodsCount++;
1336 result = new Item(bootstrapMethodIndex);
1337 result.set(position, hashCode);
1338 put(result);
1339 }
1340
1341 // now, create the InvokeDynamic constant
1342 key3.set(name, desc, bootstrapMethodIndex);
1343 result = get(key3);
1344 if (result == null) {
1345 put122(INDY, bootstrapMethodIndex, newNameType(name, desc));
1346 result = new Item(index++, key3);
1347 put(result);
1348 }
1349 return result;
1350 }
1351
1352 /**
1353 * Adds an invokedynamic reference to the constant pool of the class being
1354 * build. Does nothing if the constant pool already contains a similar item.
1355 * <i>This method is intended for {@link Attribute} sub classes, and is
1356 * normally not needed by class generators or adapters.</i>
1357 *
1358 * @param name
1359 * name of the invoked method.
1360 * @param desc
1361 * descriptor of the invoke method.
1362 * @param bsm
1363 * the bootstrap method.
1364 * @param bsmArgs
1365 * the bootstrap method constant arguments.
1366 *
1367 * @return the index of a new or already existing invokedynamic reference
1368 * item.
1369 */
1370 public int newInvokeDynamic(final String name, final String desc,
1371 final Handle bsm, final Object... bsmArgs) {
1372 return newInvokeDynamicItem(name, desc, bsm, bsmArgs).index;
1373 }
1374
1375 /**
1376 * Adds a field reference to the constant pool of the class being build.
1377 * Does nothing if the constant pool already contains a similar item.
1378 *
1379 * @param owner
1380 * the internal name of the field's owner class.
1381 * @param name
1382 * the field's name.
1383 * @param desc
1384 * the field's descriptor.
1385 * @return a new or already existing field reference item.
1386 */
1387 Item newFieldItem(final String owner, final String name, final String desc) {
1388 key3.set(FIELD, owner, name, desc);
1389 Item result = get(key3);
1390 if (result == null) {
1391 put122(FIELD, newClass(owner), newNameType(name, desc));
1392 result = new Item(index++, key3);
1393 put(result);
1394 }
1395 return result;
1396 }
1397
1398 /**
1399 * Adds a field reference to the constant pool of the class being build.
1400 * Does nothing if the constant pool already contains a similar item.
1401 * <i>This method is intended for {@link Attribute} sub classes, and is
1402 * normally not needed by class generators or adapters.</i>
1403 *
1404 * @param owner
1405 * the internal name of the field's owner class.
1406 * @param name
1407 * the field's name.
1408 * @param desc
1409 * the field's descriptor.
1410 * @return the index of a new or already existing field reference item.
1411 */
1412 public int newField(final String owner, final String name, final String desc) {
1413 return newFieldItem(owner, name, desc).index;
1414 }
1415
1416 /**
1417 * Adds a method reference to the constant pool of the class being build.
1418 * Does nothing if the constant pool already contains a similar item.
1419 *
1420 * @param owner
1421 * the internal name of the method's owner class.
1422 * @param name
1423 * the method's name.
1424 * @param desc
1425 * the method's descriptor.
1426 * @param itf
1427 * <tt>true</tt> if <tt>owner</tt> is an interface.
1428 * @return a new or already existing method reference item.
1429 */
1430 Item newMethodItem(final String owner, final String name,
1431 final String desc, final boolean itf) {
1432 int type = itf ? IMETH : METH;
1433 key3.set(type, owner, name, desc);
1434 Item result = get(key3);
1435 if (result == null) {
1436 put122(type, newClass(owner), newNameType(name, desc));
1437 result = new Item(index++, key3);
1438 put(result);
1439 }
1440 return result;
1441 }
1442
1443 /**
1444 * Adds a method reference to the constant pool of the class being build.
1445 * Does nothing if the constant pool already contains a similar item.
1446 * <i>This method is intended for {@link Attribute} sub classes, and is
1447 * normally not needed by class generators or adapters.</i>
1448 *
1449 * @param owner
1450 * the internal name of the method's owner class.
1451 * @param name
1452 * the method's name.
1453 * @param desc
1454 * the method's descriptor.
1455 * @param itf
1456 * <tt>true</tt> if <tt>owner</tt> is an interface.
1457 * @return the index of a new or already existing method reference item.
1458 */
1459 public int newMethod(final String owner, final String name,
1460 final String desc, final boolean itf) {
1461 return newMethodItem(owner, name, desc, itf).index;
1462 }
1463
1464 /**
1465 * Adds an integer to the constant pool of the class being build. Does
1466 * nothing if the constant pool already contains a similar item.
1467 *
1468 * @param value
1469 * the int value.
1470 * @return a new or already existing int item.
1471 */
1472 Item newInteger(final int value) {
1473 key.set(value);
1474 Item result = get(key);
1475 if (result == null) {
1476 pool.putByte(INT).putInt(value);
1477 result = new Item(index++, key);
1478 put(result);
1479 }
1480 return result;
1481 }
1482
1483 /**
1484 * Adds a float to the constant pool of the class being build. Does nothing
1485 * if the constant pool already contains a similar item.
1486 *
1487 * @param value
1488 * the float value.
1489 * @return a new or already existing float item.
1490 */
1491 Item newFloat(final float value) {
1492 key.set(value);
1493 Item result = get(key);
1494 if (result == null) {
1495 pool.putByte(FLOAT).putInt(key.intVal);
1496 result = new Item(index++, key);
1497 put(result);
1498 }
1499 return result;
1500 }
1501
1502 /**
1503 * Adds a long to the constant pool of the class being build. Does nothing
1504 * if the constant pool already contains a similar item.
1505 *
1506 * @param value
1507 * the long value.
1508 * @return a new or already existing long item.
1509 */
1510 Item newLong(final long value) {
1511 key.set(value);
1512 Item result = get(key);
1513 if (result == null) {
1514 pool.putByte(LONG).putLong(value);
1515 result = new Item(index, key);
1516 index += 2;
1517 put(result);
1518 }
1519 return result;
1520 }
1521
1522 /**
1523 * Adds a double to the constant pool of the class being build. Does nothing
1524 * if the constant pool already contains a similar item.
1525 *
1526 * @param value
1527 * the double value.
1528 * @return a new or already existing double item.
1529 */
1530 Item newDouble(final double value) {
1531 key.set(value);
1532 Item result = get(key);
1533 if (result == null) {
1534 pool.putByte(DOUBLE).putLong(key.longVal);
1535 result = new Item(index, key);
1536 index += 2;
1537 put(result);
1538 }
1539 return result;
1540 }
1541
1542 /**
1543 * Adds a string to the constant pool of the class being build. Does nothing
1544 * if the constant pool already contains a similar item.
1545 *
1546 * @param value
1547 * the String value.
1548 * @return a new or already existing string item.
1549 */
1550 private Item newString(final String value) {
1551 key2.set(STR, value, null, null);
1552 Item result = get(key2);
1553 if (result == null) {
1554 pool.put12(STR, newUTF8(value));
1555 result = new Item(index++, key2);
1556 put(result);
1557 }
1558 return result;
1559 }
1560
1561 /**
1562 * Adds a name and type to the constant pool of the class being build. Does
1563 * nothing if the constant pool already contains a similar item. <i>This
1564 * method is intended for {@link Attribute} sub classes, and is normally not
1565 * needed by class generators or adapters.</i>
1566 *
1567 * @param name
1568 * a name.
1569 * @param desc
1570 * a type descriptor.
1571 * @return the index of a new or already existing name and type item.
1572 */
1573 public int newNameType(final String name, final String desc) {
1574 return newNameTypeItem(name, desc).index;
1575 }
1576
1577 /**
1578 * Adds a name and type to the constant pool of the class being build. Does
1579 * nothing if the constant pool already contains a similar item.
1580 *
1581 * @param name
1582 * a name.
1583 * @param desc
1584 * a type descriptor.
1585 * @return a new or already existing name and type item.
1586 */
1587 Item newNameTypeItem(final String name, final String desc) {
1588 key2.set(NAME_TYPE, name, desc, null);
1589 Item result = get(key2);
1590 if (result == null) {
1591 put122(NAME_TYPE, newUTF8(name), newUTF8(desc));
1592 result = new Item(index++, key2);
1593 put(result);
1594 }
1595 return result;
1596 }
1597
1598 /**
1599 * Adds the given internal name to {@link #typeTable} and returns its index.
1600 * Does nothing if the type table already contains this internal name.
1601 *
1602 * @param type
1603 * the internal name to be added to the type table.
1604 * @return the index of this internal name in the type table.
1605 */
1606 int addType(final String type) {
1607 key.set(TYPE_NORMAL, type, null, null);
1608 Item result = get(key);
1609 if (result == null) {
1610 result = addType(key);
1611 }
1612 return result.index;
1613 }
1614
1615 /**
1616 * Adds the given "uninitialized" type to {@link #typeTable} and returns its
1617 * index. This method is used for UNINITIALIZED types, made of an internal
1618 * name and a bytecode offset.
1619 *
1620 * @param type
1621 * the internal name to be added to the type table.
1622 * @param offset
1623 * the bytecode offset of the NEW instruction that created this
1624 * UNINITIALIZED type value.
1625 * @return the index of this internal name in the type table.
1626 */
1627 int addUninitializedType(final String type, final int offset) {
1628 key.type = TYPE_UNINIT;
1629 key.intVal = offset;
1630 key.strVal1 = type;
1631 key.hashCode = 0x7FFFFFFF & (TYPE_UNINIT + type.hashCode() + offset);
1632 Item result = get(key);
1633 if (result == null) {
1634 result = addType(key);
1635 }
1636 return result.index;
1637 }
1638
1639 /**
1640 * Adds the given Item to {@link #typeTable}.
1641 *
1642 * @param item
1643 * the value to be added to the type table.
1644 * @return the added Item, which a new Item instance with the same value as
1645 * the given Item.
1646 */
1647 private Item addType(final Item item) {
1648 ++typeCount;
1649 Item result = new Item(typeCount, key);
1650 put(result);
1651 if (typeTable == null) {
1652 typeTable = new Item[16];
1653 }
1654 if (typeCount == typeTable.length) {
1655 Item[] newTable = new Item[2 * typeTable.length];
1656 System.arraycopy(typeTable, 0, newTable, 0, typeTable.length);
1657 typeTable = newTable;
1658 }
1659 typeTable[typeCount] = result;
1660 return result;
1661 }
1662
1663 /**
1664 * Returns the index of the common super type of the two given types. This
1665 * method calls {@link #getCommonSuperClass} and caches the result in the
1666 * {@link #items} hash table to speedup future calls with the same
1667 * parameters.
1668 *
1669 * @param type1
1670 * index of an internal name in {@link #typeTable}.
1671 * @param type2
1672 * index of an internal name in {@link #typeTable}.
1673 * @return the index of the common super type of the two given types.
1674 */
1675 int getMergedType(final int type1, final int type2) {
1676 key2.type = TYPE_MERGED;
1677 key2.longVal = type1 | (((long) type2) << 32);
1678 key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
1679 Item result = get(key2);
1680 if (result == null) {
1681 String t = typeTable[type1].strVal1;
1682 String u = typeTable[type2].strVal1;
1683 key2.intVal = addType(getCommonSuperClass(t, u));
1684 result = new Item((short) 0, key2);
1685 put(result);
1686 }
1687 return result.intVal;
1688 }
1689
1690 /**
1691 * Returns the common super type of the two given types. The default
1692 * implementation of this method <i>loads</i> the two given classes and uses
1693 * the java.lang.Class methods to find the common super class. It can be
1694 * overridden to compute this common super type in other ways, in particular
1695 * without actually loading any class, or to take into account the class
1696 * that is currently being generated by this ClassWriter, which can of
1697 * course not be loaded since it is under construction.
1698 *
1699 * @param type1
1700 * the internal name of a class.
1701 * @param type2
1702 * the internal name of another class.
1703 * @return the internal name of the common super class of the two given
1704 * classes.
1705 */
1706 protected String getCommonSuperClass(final String type1, final String type2) {
1707 Class<?> c, d;
1708 ClassLoader classLoader = getClass().getClassLoader();
1709 try {
1710 c = Class.forName(type1.replace('/', '.'), false, classLoader);
1711 d = Class.forName(type2.replace('/', '.'), false, classLoader);
1712 } catch (Exception e) {
1713 throw new RuntimeException(e.toString());
1714 }
1715 if (c.isAssignableFrom(d)) {
1716 return type1;
1717 }
1718 if (d.isAssignableFrom(c)) {
1719 return type2;
1720 }
1721 if (c.isInterface() || d.isInterface()) {
1722 return "java/lang/Object";
1723 } else {
1724 do {
1725 c = c.getSuperclass();
1726 } while (!c.isAssignableFrom(d));
1727 return c.getName().replace('.', '/');
1728 }
1729 }
1730
1731 /**
1732 * Returns the constant pool's hash table item which is equal to the given
1733 * item.
1734 *
1735 * @param key
1736 * a constant pool item.
1737 * @return the constant pool's hash table item which is equal to the given
1738 * item, or <tt>null</tt> if there is no such item.
1739 */
1740 private Item get(final Item key) {
1741 Item i = items[key.hashCode % items.length];
1742 while (i != null && (i.type != key.type || !key.isEqualTo(i))) {
1743 i = i.next;
1744 }
1745 return i;
1746 }
1747
1748 /**
1749 * Puts the given item in the constant pool's hash table. The hash table
1750 * <i>must</i> not already contains this item.
1751 *
1752 * @param i
1753 * the item to be added to the constant pool's hash table.
1754 */
1755 private void put(final Item i) {
1756 if (index + typeCount > threshold) {
1757 int ll = items.length;
1758 int nl = ll * 2 + 1;
1759 Item[] newItems = new Item[nl];
1760 for (int l = ll - 1; l >= 0; --l) {
1761 Item j = items[l];
1762 while (j != null) {
1763 int index = j.hashCode % newItems.length;
1764 Item k = j.next;
1765 j.next = newItems[index];
1766 newItems[index] = j;
1767 j = k;
1768 }
1769 }
1770 items = newItems;
1771 threshold = (int) (nl * 0.75);
1772 }
1773 int index = i.hashCode % items.length;
1774 i.next = items[index];
1775 items[index] = i;
1776 }
1777
1778 /**
1779 * Puts one byte and two shorts into the constant pool.
1780 *
1781 * @param b
1782 * a byte.
1783 * @param s1
1784 * a short.
1785 * @param s2
1786 * another short.
1787 */
1788 private void put122(final int b, final int s1, final int s2) {
1789 pool.put12(b, s1).putShort(s2);
1790 }
1791
1792 /**
1793 * Puts two bytes and one short into the constant pool.
1794 *
1795 * @param b1
1796 * a byte.
1797 * @param b2
1798 * another byte.
1799 * @param s
1800 * a short.
1801 */
1802 private void put112(final int b1, final int b2, final int s) {
1803 pool.put11(b1, b2).putShort(s);
1804 }
1805 }