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 */ 59package jdk.internal.org.objectweb.asm; 60 61/** 62 * A visitor to visit a Java method. The methods of this class must be called in 63 * the following order: ( <tt>visitParameter</tt> )* [ 64 * <tt>visitAnnotationDefault</tt> ] ( <tt>visitAnnotation</tt> | 65 * <tt>visitParameterAnnotation</tt> <tt>visitTypeAnnotation</tt> | 66 * <tt>visitAttribute</tt> )* [ <tt>visitCode</tt> ( <tt>visitFrame</tt> | 67 * <tt>visit<i>X</i>Insn</tt> | <tt>visitLabel</tt> | 68 * <tt>visitInsnAnnotation</tt> | <tt>visitTryCatchBlock</tt> | 69 * <tt>visitTryCatchAnnotation</tt> | <tt>visitLocalVariable</tt> | 70 * <tt>visitLocalVariableAnnotation</tt> | <tt>visitLineNumber</tt> )* 71 * <tt>visitMaxs</tt> ] <tt>visitEnd</tt>. In addition, the 72 * <tt>visit<i>X</i>Insn</tt> and <tt>visitLabel</tt> methods must be called in 73 * the sequential order of the bytecode instructions of the visited code, 74 * <tt>visitInsnAnnotation</tt> must be called <i>after</i> the annotated 75 * instruction, <tt>visitTryCatchBlock</tt> must be called <i>before</i> the 76 * labels passed as arguments have been visited, 77 * <tt>visitTryCatchBlockAnnotation</tt> must be called <i>after</i> the 78 * corresponding try catch block has been visited, and the 79 * <tt>visitLocalVariable</tt>, <tt>visitLocalVariableAnnotation</tt> and 80 * <tt>visitLineNumber</tt> methods must be called <i>after</i> the labels 81 * passed as arguments have been visited. 82 * 83 * @author Eric Bruneton 84 */ 85public abstract class MethodVisitor { 86 87 /** 88 * The ASM API version implemented by this visitor. The value of this field 89 * must be one of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. 90 */ 91 protected final int api; 92 93 /** 94 * The method visitor to which this visitor must delegate method calls. May 95 * be null. 96 */ 97 protected MethodVisitor mv; 98 99 /** 100 * Constructs a new {@link MethodVisitor}. 101 * 102 * @param api 103 * the ASM API version implemented by this visitor. Must be one 104 * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. 105 */ 106 public MethodVisitor(final int api) { 107 this(api, null); 108 } 109 110 /** 111 * Constructs a new {@link MethodVisitor}. 112 * 113 * @param api 114 * the ASM API version implemented by this visitor. Must be one 115 * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. 116 * @param mv 117 * the method visitor to which this visitor must delegate method 118 * calls. May be null. 119 */ 120 public MethodVisitor(final int api, final MethodVisitor mv) { 121 if (api != Opcodes.ASM4 && api != Opcodes.ASM5) { 122 throw new IllegalArgumentException(); 123 } 124 this.api = api; 125 this.mv = mv; 126 } 127 128 // ------------------------------------------------------------------------- 129 // Parameters, annotations and non standard attributes 130 // ------------------------------------------------------------------------- 131 132 /** 133 * Visits a parameter of this method. 134 * 135 * @param name 136 * parameter name or null if none is provided. 137 * @param access 138 * the parameter's access flags, only <tt>ACC_FINAL</tt>, 139 * <tt>ACC_SYNTHETIC</tt> or/and <tt>ACC_MANDATED</tt> are 140 * allowed (see {@link Opcodes}). 141 */ 142 public void visitParameter(String name, int access) { 143 if (api < Opcodes.ASM5) { 144 throw new RuntimeException(); 145 } 146 if (mv != null) { 147 mv.visitParameter(name, access); 148 } 149 } 150 151 /** 152 * Visits the default value of this annotation interface method. 153 * 154 * @return a visitor to the visit the actual default value of this 155 * annotation interface method, or <tt>null</tt> if this visitor is 156 * not interested in visiting this default value. The 'name' 157 * parameters passed to the methods of this annotation visitor are 158 * ignored. Moreover, exacly one visit method must be called on this 159 * annotation visitor, followed by visitEnd. 160 */ 161 public AnnotationVisitor visitAnnotationDefault() { 162 if (mv != null) { 163 return mv.visitAnnotationDefault(); 164 } 165 return null; 166 } 167 168 /** 169 * Visits an annotation of this method. 170 * 171 * @param desc 172 * the class descriptor of the annotation class. 173 * @param visible 174 * <tt>true</tt> if the annotation is visible at runtime. 175 * @return a visitor to visit the annotation values, or <tt>null</tt> if 176 * this visitor is not interested in visiting this annotation. 177 */ 178 public AnnotationVisitor visitAnnotation(String desc, boolean visible) { 179 if (mv != null) { 180 return mv.visitAnnotation(desc, visible); 181 } 182 return null; 183 } 184 185 /** 186 * Visits an annotation on a type in the method signature. 187 * 188 * @param typeRef 189 * a reference to the annotated type. The sort of this type 190 * reference must be {@link TypeReference#METHOD_TYPE_PARAMETER 191 * METHOD_TYPE_PARAMETER}, 192 * {@link TypeReference#METHOD_TYPE_PARAMETER_BOUND 193 * METHOD_TYPE_PARAMETER_BOUND}, 194 * {@link TypeReference#METHOD_RETURN METHOD_RETURN}, 195 * {@link TypeReference#METHOD_RECEIVER METHOD_RECEIVER}, 196 * {@link TypeReference#METHOD_FORMAL_PARAMETER 197 * METHOD_FORMAL_PARAMETER} or {@link TypeReference#THROWS 198 * THROWS}. See {@link TypeReference}. 199 * @param typePath 200 * the path to the annotated type argument, wildcard bound, array 201 * element type, or static inner type within 'typeRef'. May be 202 * <tt>null</tt> if the annotation targets 'typeRef' as a whole. 203 * @param desc 204 * the class descriptor of the annotation class. 205 * @param visible 206 * <tt>true</tt> if the annotation is visible at runtime. 207 * @return a visitor to visit the annotation values, or <tt>null</tt> if 208 * this visitor is not interested in visiting this annotation. 209 */ 210 public AnnotationVisitor visitTypeAnnotation(int typeRef, 211 TypePath typePath, String desc, boolean visible) { 212 if (api < Opcodes.ASM5) { 213 throw new RuntimeException(); 214 } 215 if (mv != null) { 216 return mv.visitTypeAnnotation(typeRef, typePath, desc, visible); 217 } 218 return null; 219 } 220 221 /** 222 * Visits an annotation of a parameter this method. 223 * 224 * @param parameter 225 * the parameter index. 226 * @param desc 227 * the class descriptor of the annotation class. 228 * @param visible 229 * <tt>true</tt> if the annotation is visible at runtime. 230 * @return a visitor to visit the annotation values, or <tt>null</tt> if 231 * this visitor is not interested in visiting this annotation. 232 */ 233 public AnnotationVisitor visitParameterAnnotation(int parameter, 234 String desc, boolean visible) { 235 if (mv != null) { 236 return mv.visitParameterAnnotation(parameter, desc, visible); 237 } 238 return null; 239 } 240 241 /** 242 * Visits a non standard attribute of this method. 243 * 244 * @param attr 245 * an attribute. 246 */ 247 public void visitAttribute(Attribute attr) { 248 if (mv != null) { 249 mv.visitAttribute(attr); 250 } 251 } 252 253 /** 254 * Starts the visit of the method's code, if any (i.e. non abstract method). 255 */ 256 public void visitCode() { 257 if (mv != null) { 258 mv.visitCode(); 259 } 260 } 261 262 /** 263 * Visits the current state of the local variables and operand stack 264 * elements. This method must(*) be called <i>just before</i> any 265 * instruction <b>i</b> that follows an unconditional branch instruction 266 * such as GOTO or THROW, that is the target of a jump instruction, or that 267 * starts an exception handler block. The visited types must describe the 268 * values of the local variables and of the operand stack elements <i>just 269 * before</i> <b>i</b> is executed.<br> 270 * <br> 271 * (*) this is mandatory only for classes whose version is greater than or 272 * equal to {@link Opcodes#V1_6 V1_6}. <br> 273 * <br> 274 * The frames of a method must be given either in expanded form, or in 275 * compressed form (all frames must use the same format, i.e. you must not 276 * mix expanded and compressed frames within a single method): 277 * <ul> 278 * <li>In expanded form, all frames must have the F_NEW type.</li> 279 * <li>In compressed form, frames are basically "deltas" from the state of 280 * the previous frame: 281 * <ul> 282 * <li>{@link Opcodes#F_SAME} representing frame with exactly the same 283 * locals as the previous frame and with the empty stack.</li> 284 * <li>{@link Opcodes#F_SAME1} representing frame with exactly the same 285 * locals as the previous frame and with single value on the stack ( 286 * <code>nStack</code> is 1 and <code>stack[0]</code> contains value for the 287 * type of the stack item).</li> 288 * <li>{@link Opcodes#F_APPEND} representing frame with current locals are 289 * the same as the locals in the previous frame, except that additional 290 * locals are defined (<code>nLocal</code> is 1, 2 or 3 and 291 * <code>local</code> elements contains values representing added types).</li> 292 * <li>{@link Opcodes#F_CHOP} representing frame with current locals are the 293 * same as the locals in the previous frame, except that the last 1-3 locals 294 * are absent and with the empty stack (<code>nLocals</code> is 1, 2 or 3).</li> 295 * <li>{@link Opcodes#F_FULL} representing complete frame data.</li> 296 * </ul> 297 * </li> 298 * </ul> 299 * <br> 300 * In both cases the first frame, corresponding to the method's parameters 301 * and access flags, is implicit and must not be visited. Also, it is 302 * illegal to visit two or more frames for the same code location (i.e., at 303 * least one instruction must be visited between two calls to visitFrame). 304 * 305 * @param type 306 * the type of this stack map frame. Must be 307 * {@link Opcodes#F_NEW} for expanded frames, or 308 * {@link Opcodes#F_FULL}, {@link Opcodes#F_APPEND}, 309 * {@link Opcodes#F_CHOP}, {@link Opcodes#F_SAME} or 310 * {@link Opcodes#F_APPEND}, {@link Opcodes#F_SAME1} for 311 * compressed frames. 312 * @param nLocal 313 * the number of local variables in the visited frame. 314 * @param local 315 * the local variable types in this frame. This array must not be 316 * modified. Primitive types are represented by 317 * {@link Opcodes#TOP}, {@link Opcodes#INTEGER}, 318 * {@link Opcodes#FLOAT}, {@link Opcodes#LONG}, 319 * {@link Opcodes#DOUBLE},{@link Opcodes#NULL} or 320 * {@link Opcodes#UNINITIALIZED_THIS} (long and double are 321 * represented by a single element). Reference types are 322 * represented by String objects (representing internal names), 323 * and uninitialized types by Label objects (this label 324 * designates the NEW instruction that created this uninitialized 325 * value). 326 * @param nStack 327 * the number of operand stack elements in the visited frame. 328 * @param stack 329 * the operand stack types in this frame. This array must not be 330 * modified. Its content has the same format as the "local" 331 * array. 332 * @throws IllegalStateException 333 * if a frame is visited just after another one, without any 334 * instruction between the two (unless this frame is a 335 * Opcodes#F_SAME frame, in which case it is silently ignored). 336 */ 337 public void visitFrame(int type, int nLocal, Object[] local, int nStack, 338 Object[] stack) { 339 if (mv != null) { 340 mv.visitFrame(type, nLocal, local, nStack, stack); 341 } 342 } 343 344 // ------------------------------------------------------------------------- 345 // Normal instructions 346 // ------------------------------------------------------------------------- 347 348 /** 349 * Visits a zero operand instruction. 350 * 351 * @param opcode 352 * the opcode of the instruction to be visited. This opcode is 353 * either NOP, ACONST_NULL, ICONST_M1, ICONST_0, ICONST_1, 354 * ICONST_2, ICONST_3, ICONST_4, ICONST_5, LCONST_0, LCONST_1, 355 * FCONST_0, FCONST_1, FCONST_2, DCONST_0, DCONST_1, IALOAD, 356 * LALOAD, FALOAD, DALOAD, AALOAD, BALOAD, CALOAD, SALOAD, 357 * IASTORE, LASTORE, FASTORE, DASTORE, AASTORE, BASTORE, CASTORE, 358 * SASTORE, POP, POP2, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, 359 * DUP2_X2, SWAP, IADD, LADD, FADD, DADD, ISUB, LSUB, FSUB, DSUB, 360 * IMUL, LMUL, FMUL, DMUL, IDIV, LDIV, FDIV, DDIV, IREM, LREM, 361 * FREM, DREM, INEG, LNEG, FNEG, DNEG, ISHL, LSHL, ISHR, LSHR, 362 * IUSHR, LUSHR, IAND, LAND, IOR, LOR, IXOR, LXOR, I2L, I2F, I2D, 363 * L2I, L2F, L2D, F2I, F2L, F2D, D2I, D2L, D2F, I2B, I2C, I2S, 364 * LCMP, FCMPL, FCMPG, DCMPL, DCMPG, IRETURN, LRETURN, FRETURN, 365 * DRETURN, ARETURN, RETURN, ARRAYLENGTH, ATHROW, MONITORENTER, 366 * or MONITOREXIT. 367 */ 368 public void visitInsn(int opcode) { 369 if (mv != null) { 370 mv.visitInsn(opcode); 371 } 372 } 373 374 /** 375 * Visits an instruction with a single int operand. 376 * 377 * @param opcode 378 * the opcode of the instruction to be visited. This opcode is 379 * either BIPUSH, SIPUSH or NEWARRAY. 380 * @param operand 381 * the operand of the instruction to be visited.<br> 382 * When opcode is BIPUSH, operand value should be between 383 * Byte.MIN_VALUE and Byte.MAX_VALUE.<br> 384 * When opcode is SIPUSH, operand value should be between 385 * Short.MIN_VALUE and Short.MAX_VALUE.<br> 386 * When opcode is NEWARRAY, operand value should be one of 387 * {@link Opcodes#T_BOOLEAN}, {@link Opcodes#T_CHAR}, 388 * {@link Opcodes#T_FLOAT}, {@link Opcodes#T_DOUBLE}, 389 * {@link Opcodes#T_BYTE}, {@link Opcodes#T_SHORT}, 390 * {@link Opcodes#T_INT} or {@link Opcodes#T_LONG}. 391 */ 392 public void visitIntInsn(int opcode, int operand) { 393 if (mv != null) { 394 mv.visitIntInsn(opcode, operand); 395 } 396 } 397 398 /** 399 * Visits a local variable instruction. A local variable instruction is an 400 * instruction that loads or stores the value of a local variable. 401 * 402 * @param opcode 403 * the opcode of the local variable instruction to be visited. 404 * This opcode is either ILOAD, LLOAD, FLOAD, DLOAD, ALOAD, 405 * ISTORE, LSTORE, FSTORE, DSTORE, ASTORE or RET. 406 * @param var 407 * the operand of the instruction to be visited. This operand is 408 * the index of a local variable. 409 */ 410 public void visitVarInsn(int opcode, int var) { 411 if (mv != null) { 412 mv.visitVarInsn(opcode, var); 413 } 414 } 415 416 /** 417 * Visits a type instruction. A type instruction is an instruction that 418 * takes the internal name of a class as parameter. 419 * 420 * @param opcode 421 * the opcode of the type instruction to be visited. This opcode 422 * is either NEW, ANEWARRAY, CHECKCAST or INSTANCEOF. 423 * @param type 424 * the operand of the instruction to be visited. This operand 425 * must be the internal name of an object or array class (see 426 * {@link Type#getInternalName() getInternalName}). 427 */ 428 public void visitTypeInsn(int opcode, String type) { 429 if (mv != null) { 430 mv.visitTypeInsn(opcode, type); 431 } 432 } 433 434 /** 435 * Visits a field instruction. A field instruction is an instruction that 436 * loads or stores the value of a field of an object. 437 * 438 * @param opcode 439 * the opcode of the type instruction to be visited. This opcode 440 * is either GETSTATIC, PUTSTATIC, GETFIELD or PUTFIELD. 441 * @param owner 442 * the internal name of the field's owner class (see 443 * {@link Type#getInternalName() getInternalName}). 444 * @param name 445 * the field's name. 446 * @param desc 447 * the field's descriptor (see {@link Type Type}). 448 */ 449 public void visitFieldInsn(int opcode, String owner, String name, 450 String desc) { 451 if (mv != null) { 452 mv.visitFieldInsn(opcode, owner, name, desc); 453 } 454 } 455 456 /** 457 * Visits a method instruction. A method instruction is an instruction that 458 * invokes a method. 459 * 460 * @param opcode 461 * the opcode of the type instruction to be visited. This opcode 462 * is either INVOKEVIRTUAL, INVOKESPECIAL, INVOKESTATIC or 463 * INVOKEINTERFACE. 464 * @param owner 465 * the internal name of the method's owner class (see 466 * {@link Type#getInternalName() getInternalName}). 467 * @param name 468 * the method's name. 469 * @param desc 470 * the method's descriptor (see {@link Type Type}). 471 */ 472 @Deprecated 473 public void visitMethodInsn(int opcode, String owner, String name, 474 String desc) { 475 if (api >= Opcodes.ASM5) { 476 boolean itf = opcode == Opcodes.INVOKEINTERFACE; 477 visitMethodInsn(opcode, owner, name, desc, itf); 478 return; 479 } 480 if (mv != null) { 481 mv.visitMethodInsn(opcode, owner, name, desc); 482 } 483 } 484 485 /** 486 * Visits a method instruction. A method instruction is an instruction that 487 * invokes a method. 488 * 489 * @param opcode 490 * the opcode of the type instruction to be visited. This opcode 491 * is either INVOKEVIRTUAL, INVOKESPECIAL, INVOKESTATIC or 492 * INVOKEINTERFACE. 493 * @param owner 494 * the internal name of the method's owner class (see 495 * {@link Type#getInternalName() getInternalName}). 496 * @param name 497 * the method's name. 498 * @param desc 499 * the method's descriptor (see {@link Type Type}). 500 * @param itf 501 * if the method's owner class is an interface. 502 */ 503 public void visitMethodInsn(int opcode, String owner, String name, 504 String desc, boolean itf) { 505 if (api < Opcodes.ASM5) { 506 if (itf != (opcode == Opcodes.INVOKEINTERFACE)) { 507 throw new IllegalArgumentException( 508 "INVOKESPECIAL/STATIC on interfaces require ASM 5"); 509 } 510 visitMethodInsn(opcode, owner, name, desc); 511 return; 512 } 513 if (mv != null) { 514 mv.visitMethodInsn(opcode, owner, name, desc, itf); 515 } 516 } 517 518 /** 519 * Visits an invokedynamic instruction. 520 * 521 * @param name 522 * the method's name. 523 * @param desc 524 * the method's descriptor (see {@link Type Type}). 525 * @param bsm 526 * the bootstrap method. 527 * @param bsmArgs 528 * the bootstrap method constant arguments. Each argument must be 529 * an {@link Integer}, {@link Float}, {@link Long}, 530 * {@link Double}, {@link String}, {@link Type} or {@link Handle} 531 * value. This method is allowed to modify the content of the 532 * array so a caller should expect that this array may change. 533 */ 534 public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, 535 Object... bsmArgs) { 536 if (mv != null) { 537 mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs); 538 } 539 } 540 541 /** 542 * Visits a jump instruction. A jump instruction is an instruction that may 543 * jump to another instruction. 544 * 545 * @param opcode 546 * the opcode of the type instruction to be visited. This opcode 547 * is either IFEQ, IFNE, IFLT, IFGE, IFGT, IFLE, IF_ICMPEQ, 548 * IF_ICMPNE, IF_ICMPLT, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, 549 * IF_ACMPEQ, IF_ACMPNE, GOTO, JSR, IFNULL or IFNONNULL. 550 * @param label 551 * the operand of the instruction to be visited. This operand is 552 * a label that designates the instruction to which the jump 553 * instruction may jump. 554 */ 555 public void visitJumpInsn(int opcode, Label label) { 556 if (mv != null) { 557 mv.visitJumpInsn(opcode, label); 558 } 559 } 560 561 /** 562 * Visits a label. A label designates the instruction that will be visited 563 * just after it. 564 * 565 * @param label 566 * a {@link Label Label} object. 567 */ 568 public void visitLabel(Label label) { 569 if (mv != null) { 570 mv.visitLabel(label); 571 } 572 } 573 574 // ------------------------------------------------------------------------- 575 // Special instructions 576 // ------------------------------------------------------------------------- 577 578 /** 579 * Visits a LDC instruction. Note that new constant types may be added in 580 * future versions of the Java Virtual Machine. To easily detect new 581 * constant types, implementations of this method should check for 582 * unexpected constant types, like this: 583 * 584 * <pre> 585 * if (cst instanceof Integer) { 586 * // ... 587 * } else if (cst instanceof Float) { 588 * // ... 589 * } else if (cst instanceof Long) { 590 * // ... 591 * } else if (cst instanceof Double) { 592 * // ... 593 * } else if (cst instanceof String) { 594 * // ... 595 * } else if (cst instanceof Type) { 596 * int sort = ((Type) cst).getSort(); 597 * if (sort == Type.OBJECT) { 598 * // ... 599 * } else if (sort == Type.ARRAY) { 600 * // ... 601 * } else if (sort == Type.METHOD) { 602 * // ... 603 * } else { 604 * // throw an exception 605 * } 606 * } else if (cst instanceof Handle) { 607 * // ... 608 * } else { 609 * // throw an exception 610 * } 611 * </pre> 612 * 613 * @param cst 614 * the constant to be loaded on the stack. This parameter must be 615 * a non null {@link Integer}, a {@link Float}, a {@link Long}, a 616 * {@link Double}, a {@link String}, a {@link Type} of OBJECT or 617 * ARRAY sort for <tt>.class</tt> constants, for classes whose 618 * version is 49.0, a {@link Type} of METHOD sort or a 619 * {@link Handle} for MethodType and MethodHandle constants, for 620 * classes whose version is 51.0. 621 */ 622 public void visitLdcInsn(Object cst) { 623 if (mv != null) { 624 mv.visitLdcInsn(cst); 625 } 626 } 627 628 /** 629 * Visits an IINC instruction. 630 * 631 * @param var 632 * index of the local variable to be incremented. 633 * @param increment 634 * amount to increment the local variable by. 635 */ 636 public void visitIincInsn(int var, int increment) { 637 if (mv != null) { 638 mv.visitIincInsn(var, increment); 639 } 640 } 641 642 /** 643 * Visits a TABLESWITCH instruction. 644 * 645 * @param min 646 * the minimum key value. 647 * @param max 648 * the maximum key value. 649 * @param dflt 650 * beginning of the default handler block. 651 * @param labels 652 * beginnings of the handler blocks. <tt>labels[i]</tt> is the 653 * beginning of the handler block for the <tt>min + i</tt> key. 654 */ 655 public void visitTableSwitchInsn(int min, int max, Label dflt, 656 Label... labels) { 657 if (mv != null) { 658 mv.visitTableSwitchInsn(min, max, dflt, labels); 659 } 660 } 661 662 /** 663 * Visits a LOOKUPSWITCH instruction. 664 * 665 * @param dflt 666 * beginning of the default handler block. 667 * @param keys 668 * the values of the keys. 669 * @param labels 670 * beginnings of the handler blocks. <tt>labels[i]</tt> is the 671 * beginning of the handler block for the <tt>keys[i]</tt> key. 672 */ 673 public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) { 674 if (mv != null) { 675 mv.visitLookupSwitchInsn(dflt, keys, labels); 676 } 677 } 678 679 /** 680 * Visits a MULTIANEWARRAY instruction. 681 * 682 * @param desc 683 * an array type descriptor (see {@link Type Type}). 684 * @param dims 685 * number of dimensions of the array to allocate. 686 */ 687 public void visitMultiANewArrayInsn(String desc, int dims) { 688 if (mv != null) { 689 mv.visitMultiANewArrayInsn(desc, dims); 690 } 691 } 692 693 /** 694 * Visits an annotation on an instruction. This method must be called just 695 * <i>after</i> the annotated instruction. It can be called several times 696 * for the same instruction. 697 * 698 * @param typeRef 699 * a reference to the annotated type. The sort of this type 700 * reference must be {@link TypeReference#INSTANCEOF INSTANCEOF}, 701 * {@link TypeReference#NEW NEW}, 702 * {@link TypeReference#CONSTRUCTOR_REFERENCE 703 * CONSTRUCTOR_REFERENCE}, {@link TypeReference#METHOD_REFERENCE 704 * METHOD_REFERENCE}, {@link TypeReference#CAST CAST}, 705 * {@link TypeReference#CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT 706 * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT}, 707 * {@link TypeReference#METHOD_INVOCATION_TYPE_ARGUMENT 708 * METHOD_INVOCATION_TYPE_ARGUMENT}, 709 * {@link TypeReference#CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT 710 * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or 711 * {@link TypeReference#METHOD_REFERENCE_TYPE_ARGUMENT 712 * METHOD_REFERENCE_TYPE_ARGUMENT}. See {@link TypeReference}. 713 * @param typePath 714 * the path to the annotated type argument, wildcard bound, array 715 * element type, or static inner type within 'typeRef'. May be 716 * <tt>null</tt> if the annotation targets 'typeRef' as a whole. 717 * @param desc 718 * the class descriptor of the annotation class. 719 * @param visible 720 * <tt>true</tt> if the annotation is visible at runtime. 721 * @return a visitor to visit the annotation values, or <tt>null</tt> if 722 * this visitor is not interested in visiting this annotation. 723 */ 724 public AnnotationVisitor visitInsnAnnotation(int typeRef, 725 TypePath typePath, String desc, boolean visible) { 726 if (api < Opcodes.ASM5) { 727 throw new RuntimeException(); 728 } 729 if (mv != null) { 730 return mv.visitInsnAnnotation(typeRef, typePath, desc, visible); 731 } 732 return null; 733 } 734 735 // ------------------------------------------------------------------------- 736 // Exceptions table entries, debug information, max stack and max locals 737 // ------------------------------------------------------------------------- 738 739 /** 740 * Visits a try catch block. 741 * 742 * @param start 743 * beginning of the exception handler's scope (inclusive). 744 * @param end 745 * end of the exception handler's scope (exclusive). 746 * @param handler 747 * beginning of the exception handler's code. 748 * @param type 749 * internal name of the type of exceptions handled by the 750 * handler, or <tt>null</tt> to catch any exceptions (for 751 * "finally" blocks). 752 * @throws IllegalArgumentException 753 * if one of the labels has already been visited by this visitor 754 * (by the {@link #visitLabel visitLabel} method). 755 */ 756 public void visitTryCatchBlock(Label start, Label end, Label handler, 757 String type) { 758 if (mv != null) { 759 mv.visitTryCatchBlock(start, end, handler, type); 760 } 761 } 762 763 /** 764 * Visits an annotation on an exception handler type. This method must be 765 * called <i>after</i> the {@link #visitTryCatchBlock} for the annotated 766 * exception handler. It can be called several times for the same exception 767 * handler. 768 * 769 * @param typeRef 770 * a reference to the annotated type. The sort of this type 771 * reference must be {@link TypeReference#EXCEPTION_PARAMETER 772 * EXCEPTION_PARAMETER}. See {@link TypeReference}. 773 * @param typePath 774 * the path to the annotated type argument, wildcard bound, array 775 * element type, or static inner type within 'typeRef'. May be 776 * <tt>null</tt> if the annotation targets 'typeRef' as a whole. 777 * @param desc 778 * the class descriptor of the annotation class. 779 * @param visible 780 * <tt>true</tt> if the annotation is visible at runtime. 781 * @return a visitor to visit the annotation values, or <tt>null</tt> if 782 * this visitor is not interested in visiting this annotation. 783 */ 784 public AnnotationVisitor visitTryCatchAnnotation(int typeRef, 785 TypePath typePath, String desc, boolean visible) { 786 if (api < Opcodes.ASM5) { 787 throw new RuntimeException(); 788 } 789 if (mv != null) { 790 return mv.visitTryCatchAnnotation(typeRef, typePath, desc, visible); 791 } 792 return null; 793 } 794 795 /** 796 * Visits a local variable declaration. 797 * 798 * @param name 799 * the name of a local variable. 800 * @param desc 801 * the type descriptor of this local variable. 802 * @param signature 803 * the type signature of this local variable. May be 804 * <tt>null</tt> if the local variable type does not use generic 805 * types. 806 * @param start 807 * the first instruction corresponding to the scope of this local 808 * variable (inclusive). 809 * @param end 810 * the last instruction corresponding to the scope of this local 811 * variable (exclusive). 812 * @param index 813 * the local variable's index. 814 * @throws IllegalArgumentException 815 * if one of the labels has not already been visited by this 816 * visitor (by the {@link #visitLabel visitLabel} method). 817 */ 818 public void visitLocalVariable(String name, String desc, String signature, 819 Label start, Label end, int index) { 820 if (mv != null) { 821 mv.visitLocalVariable(name, desc, signature, start, end, index); 822 } 823 } 824 825 /** 826 * Visits an annotation on a local variable type. 827 * 828 * @param typeRef 829 * a reference to the annotated type. The sort of this type 830 * reference must be {@link TypeReference#LOCAL_VARIABLE 831 * LOCAL_VARIABLE} or {@link TypeReference#RESOURCE_VARIABLE 832 * RESOURCE_VARIABLE}. See {@link TypeReference}. 833 * @param typePath 834 * the path to the annotated type argument, wildcard bound, array 835 * element type, or static inner type within 'typeRef'. May be 836 * <tt>null</tt> if the annotation targets 'typeRef' as a whole. 837 * @param start 838 * the fist instructions corresponding to the continuous ranges 839 * that make the scope of this local variable (inclusive). 840 * @param end 841 * the last instructions corresponding to the continuous ranges 842 * that make the scope of this local variable (exclusive). This 843 * array must have the same size as the 'start' array. 844 * @param index 845 * the local variable's index in each range. This array must have 846 * the same size as the 'start' array. 847 * @param desc 848 * the class descriptor of the annotation class. 849 * @param visible 850 * <tt>true</tt> if the annotation is visible at runtime. 851 * @return a visitor to visit the annotation values, or <tt>null</tt> if 852 * this visitor is not interested in visiting this annotation. 853 */ 854 public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, 855 TypePath typePath, Label[] start, Label[] end, int[] index, 856 String desc, boolean visible) { 857 if (api < Opcodes.ASM5) { 858 throw new RuntimeException(); 859 } 860 if (mv != null) { 861 return mv.visitLocalVariableAnnotation(typeRef, typePath, start, 862 end, index, desc, visible); 863 } 864 return null; 865 } 866 867 /** 868 * Visits a line number declaration. 869 * 870 * @param line 871 * a line number. This number refers to the source file from 872 * which the class was compiled. 873 * @param start 874 * the first instruction corresponding to this line number. 875 * @throws IllegalArgumentException 876 * if <tt>start</tt> has not already been visited by this 877 * visitor (by the {@link #visitLabel visitLabel} method). 878 */ 879 public void visitLineNumber(int line, Label start) { 880 if (mv != null) { 881 mv.visitLineNumber(line, start); 882 } 883 } 884 885 /** 886 * Visits the maximum stack size and the maximum number of local variables 887 * of the method. 888 * 889 * @param maxStack 890 * maximum stack size of the method. 891 * @param maxLocals 892 * maximum number of local variables for the method. 893 */ 894 public void visitMaxs(int maxStack, int maxLocals) { 895 if (mv != null) { 896 mv.visitMaxs(maxStack, maxLocals); 897 } 898 } 899 900 /** 901 * Visits the end of the method. This method, which is the last one to be 902 * called, is used to inform the visitor that all the annotations and 903 * attributes of the method have been visited. 904 */ 905 public void visitEnd() { 906 if (mv != null) { 907 mv.visitEnd(); 908 } 909 } 910} 911