KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > bcel > generic > IINC


1 /*
2  * Copyright 2000-2004 The Apache Software Foundation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17 package org.apache.bcel.generic;
18
19 import java.io.DataOutputStream JavaDoc;
20 import java.io.IOException JavaDoc;
21 import org.apache.bcel.util.ByteSequence;
22
23 /**
24  * IINC - Increment local variable by constant
25  *
26  * @version $Id: IINC.java 386056 2006-03-15 11:31:56Z tcurdt $
27  * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
28  */
29 public class IINC extends LocalVariableInstruction {
30
31     private boolean wide;
32     private int c;
33
34
35     /**
36      * Empty constructor needed for the Class.newInstance() statement in
37      * Instruction.readInstruction(). Not to be used otherwise.
38      */
39     IINC() {
40     }
41
42
43     /**
44      * @param n index of local variable
45      * @param c increment factor
46      */
47     public IINC(int n, int c) {
48         super(); // Default behaviour of LocalVariableInstruction causes error
49 this.opcode = org.apache.bcel.Constants.IINC;
50         this.length = (short) 3;
51         setIndex(n); // May set wide as side effect
52 setIncrement(c);
53     }
54
55
56     /**
57      * Dump instruction as byte code to stream out.
58      * @param out Output stream
59      */
60     public void dump( DataOutputStream JavaDoc out ) throws IOException JavaDoc {
61         if (wide) {
62             out.writeByte(org.apache.bcel.Constants.WIDE);
63         }
64         out.writeByte(opcode);
65         if (wide) {
66             out.writeShort(n);
67             out.writeShort(c);
68         } else {
69             out.writeByte(n);
70             out.writeByte(c);
71         }
72     }
73
74
75     private final void setWide() {
76         wide = (n > org.apache.bcel.Constants.MAX_BYTE) || (Math.abs(c) > Byte.MAX_VALUE);
77         if (wide) {
78             length = 6; // wide byte included
79 } else {
80             length = 3;
81         }
82     }
83
84
85     /**
86      * Read needed data (e.g. index) from file.
87      */
88     protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException JavaDoc {
89         this.wide = wide;
90         if (wide) {
91             length = 6;
92             n = bytes.readUnsignedShort();
93             c = bytes.readShort();
94         } else {
95             length = 3;
96             n = bytes.readUnsignedByte();
97             c = bytes.readByte();
98         }
99     }
100
101
102     /**
103      * @return mnemonic for instruction
104      */
105     public String JavaDoc toString( boolean verbose ) {
106         return super.toString(verbose) + " " + c;
107     }
108
109
110     /**
111      * Set index of local variable.
112      */
113     public final void setIndex( int n ) {
114         if (n < 0) {
115             throw new ClassGenException("Negative index value: " + n);
116         }
117         this.n = n;
118         setWide();
119     }
120
121
122     /**
123      * @return increment factor
124      */
125     public final int getIncrement() {
126         return c;
127     }
128
129
130     /**
131      * Set increment factor.
132      */
133     public final void setIncrement( int c ) {
134         this.c = c;
135         setWide();
136     }
137
138
139     /** @return int type
140      */
141     public Type getType( ConstantPoolGen cp ) {
142         return Type.INT;
143     }
144
145
146     /**
147      * Call corresponding visitor method(s). The order is:
148      * Call visitor methods of implemented interfaces first, then
149      * call methods according to the class hierarchy in descending order,
150      * i.e., the most specific visitXXX() call comes last.
151      *
152      * @param v Visitor object
153      */
154     public void accept( Visitor v ) {
155         v.visitLocalVariableInstruction(this);
156         v.visitIINC(this);
157     }
158 }
159
Popular Tags