001: /***
002: * ASM: a very small and fast Java bytecode manipulation framework
003: * Copyright (c) 2000-2007 INRIA, France Telecom
004: * All rights reserved.
005: *
006: * Redistribution and use in source and binary forms, with or without
007: * modification, are permitted provided that the following conditions
008: * are met:
009: * 1. Redistributions of source code must retain the above copyright
010: * notice, this list of conditions and the following disclaimer.
011: * 2. Redistributions in binary form must reproduce the above copyright
012: * notice, this list of conditions and the following disclaimer in the
013: * documentation and/or other materials provided with the distribution.
014: * 3. Neither the name of the copyright holders nor the names of its
015: * contributors may be used to endorse or promote products derived from
016: * this software without specific prior written permission.
017: *
018: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
019: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
020: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
021: * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
022: * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
023: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
024: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
025: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
026: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
027: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
028: * THE POSSIBILITY OF SUCH DAMAGE.
029: */package org.objectweb.asm.tree;
030:
031: import java.util.List;
032: import java.util.Map;
033:
034: import org.objectweb.asm.MethodVisitor;
035:
036: /**
037: * A node that represents a bytecode instruction. <i>An instruction can appear
038: * at most once in at most one {@link InsnList} at a time</i>.
039: *
040: * @author Eric Bruneton
041: */
042: public abstract class AbstractInsnNode {
043:
044: /**
045: * The type of {@link InsnNode} instructions.
046: */
047: public static final int INSN = 0;
048:
049: /**
050: * The type of {@link IntInsnNode} instructions.
051: */
052: public static final int INT_INSN = 1;
053:
054: /**
055: * The type of {@link VarInsnNode} instructions.
056: */
057: public static final int VAR_INSN = 2;
058:
059: /**
060: * The type of {@link TypeInsnNode} instructions.
061: */
062: public static final int TYPE_INSN = 3;
063:
064: /**
065: * The type of {@link FieldInsnNode} instructions.
066: */
067: public static final int FIELD_INSN = 4;
068:
069: /**
070: * The type of {@link MethodInsnNode} instructions.
071: */
072: public static final int METHOD_INSN = 5;
073:
074: /**
075: * The type of {@link JumpInsnNode} instructions.
076: */
077: public static final int JUMP_INSN = 6;
078:
079: /**
080: * The type of {@link LabelNode} "instructions".
081: */
082: public static final int LABEL = 7;
083:
084: /**
085: * The type of {@link LdcInsnNode} instructions.
086: */
087: public static final int LDC_INSN = 8;
088:
089: /**
090: * The type of {@link IincInsnNode} instructions.
091: */
092: public static final int IINC_INSN = 9;
093:
094: /**
095: * The type of {@link TableSwitchInsnNode} instructions.
096: */
097: public static final int TABLESWITCH_INSN = 10;
098:
099: /**
100: * The type of {@link LookupSwitchInsnNode} instructions.
101: */
102: public static final int LOOKUPSWITCH_INSN = 11;
103:
104: /**
105: * The type of {@link MultiANewArrayInsnNode} instructions.
106: */
107: public static final int MULTIANEWARRAY_INSN = 12;
108:
109: /**
110: * The type of {@link FrameNode} "instructions".
111: */
112: public static final int FRAME = 13;
113:
114: /**
115: * The type of {@link LineNumberNode} "instructions".
116: */
117: public static final int LINE = 14;
118:
119: /**
120: * The opcode of this instruction.
121: */
122: protected int opcode;
123:
124: /**
125: * Previous instruction in the list to which this instruction belongs.
126: */
127: AbstractInsnNode prev;
128:
129: /**
130: * Next instruction in the list to which this instruction belongs.
131: */
132: AbstractInsnNode next;
133:
134: /**
135: * Index of this instruction in the list to which it belongs. The value of
136: * this field is correct only when {@link InsnList#cache} is not null. A
137: * value of -1 indicates that this instruction does not belong to any
138: * {@link InsnList}.
139: */
140: int index;
141:
142: /**
143: * Constructs a new {@link AbstractInsnNode}.
144: *
145: * @param opcode the opcode of the instruction to be constructed.
146: */
147: protected AbstractInsnNode(final int opcode) {
148: this .opcode = opcode;
149: this .index = -1;
150: }
151:
152: /**
153: * Returns the opcode of this instruction.
154: *
155: * @return the opcode of this instruction.
156: */
157: public int getOpcode() {
158: return opcode;
159: }
160:
161: /**
162: * Returns the type of this instruction.
163: *
164: * @return the type of this instruction, i.e. one the constants defined in
165: * this class.
166: */
167: public abstract int getType();
168:
169: /**
170: * Returns the previous instruction in the list to which this instruction
171: * belongs, if any.
172: *
173: * @return the previous instruction in the list to which this instruction
174: * belongs, if any. May be <tt>null</tt>.
175: */
176: public AbstractInsnNode getPrevious() {
177: return prev;
178: }
179:
180: /**
181: * Returns the next instruction in the list to which this instruction
182: * belongs, if any.
183: *
184: * @return the next instruction in the list to which this instruction
185: * belongs, if any. May be <tt>null</tt>.
186: */
187: public AbstractInsnNode getNext() {
188: return next;
189: }
190:
191: /**
192: * Makes the given code visitor visit this instruction.
193: *
194: * @param cv a code visitor.
195: */
196: public abstract void accept(final MethodVisitor cv);
197:
198: /**
199: * Returns a copy of this instruction.
200: *
201: * @param labels a map from LabelNodes to cloned LabelNodes.
202: * @return a copy of this instruction. The returned instruction does not
203: * belong to any {@link InsnList}.
204: */
205: public abstract AbstractInsnNode clone(final Map labels);
206:
207: /**
208: * Returns the clone of the given label.
209: *
210: * @param label a label.
211: * @param map a map from LabelNodes to cloned LabelNodes.
212: * @return the clone of the given label.
213: */
214: static LabelNode clone(final LabelNode label, final Map map) {
215: return (LabelNode) map.get(label);
216: }
217:
218: /**
219: * Returns the clones of the given labels.
220: *
221: * @param labels a list of labels.
222: * @param map a map from LabelNodes to cloned LabelNodes.
223: * @return the clones of the given labels.
224: */
225: static LabelNode[] clone(final List labels, final Map map) {
226: LabelNode[] clones = new LabelNode[labels.size()];
227: for (int i = 0; i < clones.length; ++i) {
228: clones[i] = (LabelNode) map.get(labels.get(i));
229: }
230: return clones;
231: }
232: }
|