KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > org > apache > bcel > internal > generic > BranchInstruction


1 package com.sun.org.apache.bcel.internal.generic;
2
3 /* ====================================================================
4  * The Apache Software License, Version 1.1
5  *
6  * Copyright (c) 2001 The Apache Software Foundation. All rights
7  * reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  * notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  * notice, this list of conditions and the following disclaimer in
18  * the documentation and/or other materials provided with the
19  * distribution.
20  *
21  * 3. The end-user documentation included with the redistribution,
22  * if any, must include the following acknowledgment:
23  * "This product includes software developed by the
24  * Apache Software Foundation (http://www.apache.org/)."
25  * Alternately, this acknowledgment may appear in the software itself,
26  * if and wherever such third-party acknowledgments normally appear.
27  *
28  * 4. The names "Apache" and "Apache Software Foundation" and
29  * "Apache BCEL" must not be used to endorse or promote products
30  * derived from this software without prior written permission. For
31  * written permission, please contact apache@apache.org.
32  *
33  * 5. Products derived from this software may not be called "Apache",
34  * "Apache BCEL", nor may "Apache" appear in their name, without
35  * prior written permission of the Apache Software Foundation.
36  *
37  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
38  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
39  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
40  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
41  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
42  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
43  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
44  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
46  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
47  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
48  * SUCH DAMAGE.
49  * ====================================================================
50  *
51  * This software consists of voluntary contributions made by many
52  * individuals on behalf of the Apache Software Foundation. For more
53  * information on the Apache Software Foundation, please see
54  * <http://www.apache.org/>.
55  */
56
57 import java.io.*;
58 import com.sun.org.apache.bcel.internal.util.ByteSequence;
59
60 /**
61  * Abstract super class for branching instructions like GOTO, IFEQ, etc..
62  * Branch instructions may have a variable length, namely GOTO, JSR,
63  * LOOKUPSWITCH and TABLESWITCH.
64  *
65  * @see InstructionList
66  * @version $Id: BranchInstruction.java,v 1.1.1.1 2001/10/29 20:00:07 jvanzyl Exp $
67  * @author <A HREF="mailto:markus.dahm@berlin.de">M. Dahm</A>
68  */
69 public abstract class BranchInstruction extends Instruction implements InstructionTargeter {
70   protected int index; // Branch target relative to this instruction
71 protected InstructionHandle target; // Target object in instruction list
72 protected int position; // Byte code offset
73
74   /**
75    * Empty constructor needed for the Class.newInstance() statement in
76    * Instruction.readInstruction(). Not to be used otherwise.
77    */
78   BranchInstruction() {}
79
80   /** Common super constructor
81    * @param opcodee Instruction opcode
82    * @param target instruction to branch to
83    */
84   protected BranchInstruction(short opcode, InstructionHandle target) {
85     super(opcode, (short)3);
86     setTarget(target);
87   }
88
89   /**
90    * Dump instruction as byte code to stream out.
91    * @param out Output stream
92    */
93   public void dump(DataOutputStream out) throws IOException {
94     out.writeByte(opcode);
95
96     index = getTargetOffset();
97
98     if(Math.abs(index) >= 32767) // too large for short
99 throw new ClassGenException("Branch target offset too large for short");
100
101     out.writeShort(index); // May be negative, i.e., point backwards
102 }
103
104   /**
105    * @param target branch target
106    * @return the offset to `target' relative to this instruction
107    */
108   protected int getTargetOffset(InstructionHandle target) {
109     if(target == null)
110       throw new ClassGenException("Target of " + super.toString(true) +
111                   " is invalid null handle");
112
113     int t = target.getPosition();
114
115     if(t < 0)
116       throw new ClassGenException("Invalid branch target position offset for " +
117                   super.toString(true) + ":" + t + ":" + target);
118
119     return t - position;
120   }
121
122   /**
123    * @return the offset to this instruction's target
124    */
125   protected int getTargetOffset() { return getTargetOffset(target); }
126
127   /**
128    * Called by InstructionList.setPositions when setting the position for every
129    * instruction. In the presence of variable length instructions `setPositions'
130    * performs multiple passes over the instruction list to calculate the
131    * correct (byte) positions and offsets by calling this function.
132    *
133    * @param offset additional offset caused by preceding (variable length) instructions
134    * @param max_offset the maximum offset that may be caused by these instructions
135    * @return additional offset caused by possible change of this instruction's length
136    */
137   protected int updatePosition(int offset, int max_offset) {
138     position += offset;
139     return 0;
140   }
141
142   /**
143    * Long output format:
144    *
145    * &lt;position in byte code&gt;
146    * &lt;name of opcode&gt; "["&lt;opcode number&gt;"]"
147    * "("&lt;length of instruction&gt;")"
148    * "&lt;"&lt;target instruction&gt;"&gt;" "@"&lt;branch target offset&gt;
149    *
150    * @param verbose long/short format switch
151    * @return mnemonic for instruction
152    */
153   public String JavaDoc toString(boolean verbose) {
154     String JavaDoc s = super.toString(verbose);
155     String JavaDoc t = "null";
156
157     if(verbose) {
158       if(target != null) {
159     if(target.getInstruction() == this)
160       t = "<points to itself>";
161     else if(target.getInstruction() == null)
162       t = "<null instruction!!!?>";
163     else
164       t = target.getInstruction().toString(false); // Avoid circles
165 }
166     } else {
167       if(target != null) {
168     index = getTargetOffset();
169     t = "" + (index + position);
170       }
171     }
172
173     return s + " -> " + t;
174   }
175
176   /**
177    * Read needed data (e.g. index) from file. Conversion to a InstructionHandle
178    * is done in InstructionList(byte[]).
179    *
180    * @param bytes input stream
181    * @param wide wide prefix?
182    * @see InstructionList
183    */
184   protected void initFromFile(ByteSequence bytes, boolean wide) throws IOException
185   {
186     length = 3;
187     index = bytes.readShort();
188   }
189
190   /**
191    * @return target offset in byte code
192    */
193   public final int getIndex() { return index; }
194
195   /**
196    * @return target of branch instruction
197    */
198   public InstructionHandle getTarget() { return target; }
199
200   /**
201    * Set branch target
202    * @param target branch target
203    */
204   public void setTarget(InstructionHandle target) {
205     notifyTarget(this.target, target, this);
206     this.target = target;
207   }
208
209   /**
210    * Used by BranchInstruction, LocalVariableGen, CodeExceptionGen
211    */
212   static final void notifyTarget(InstructionHandle old_ih, InstructionHandle new_ih,
213                  InstructionTargeter t) {
214     if(old_ih != null)
215       old_ih.removeTargeter(t);
216     if(new_ih != null)
217       new_ih.addTargeter(t);
218   }
219
220   /**
221    * @param old_ih old target
222    * @param new_ih new target
223    */
224   public void updateTarget(InstructionHandle old_ih, InstructionHandle new_ih) {
225     if(target == old_ih)
226       setTarget(new_ih);
227     else
228       throw new ClassGenException("Not targeting " + old_ih + ", but " + target);
229   }
230
231   /**
232    * @return true, if ih is target of this instruction
233    */
234   public boolean containsTarget(InstructionHandle ih) {
235     return (target == ih);
236   }
237
238   /**
239    * Inform target that it's not targeted anymore.
240    */
241   void dispose() {
242     setTarget(null);
243     index=-1;
244     position=-1;
245   }
246 }
247
Popular Tags