KickJava   Java API By Example, From Geeks To Geeks.

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


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.util.StringTokenizer JavaDoc;
20 import org.apache.bcel.Constants;
21 import org.apache.bcel.classfile.Constant;
22 import org.apache.bcel.classfile.ConstantPool;
23
24 /**
25  * Super class for the INVOKExxx family of instructions.
26  *
27  * @version $Id: InvokeInstruction.java 386056 2006-03-15 11:31:56Z tcurdt $
28  * @author <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
29  */
30 public abstract class InvokeInstruction extends FieldOrMethod implements ExceptionThrower,
31         TypedInstruction, StackConsumer, StackProducer {
32
33     /**
34      * Empty constructor needed for the Class.newInstance() statement in
35      * Instruction.readInstruction(). Not to be used otherwise.
36      */
37     InvokeInstruction() {
38     }
39
40
41     /**
42      * @param index to constant pool
43      */
44     protected InvokeInstruction(short opcode, int index) {
45         super(opcode, index);
46     }
47
48
49     /**
50      * @return mnemonic for instruction with symbolic references resolved
51      */
52     public String JavaDoc toString( ConstantPool cp ) {
53         Constant c = cp.getConstant(index);
54         StringTokenizer JavaDoc tok = new StringTokenizer JavaDoc(cp.constantToString(c));
55         return Constants.OPCODE_NAMES[opcode] + " " + tok.nextToken().replace('.', '/')
56                 + tok.nextToken();
57     }
58
59
60     /**
61      * Also works for instructions whose stack effect depends on the
62      * constant pool entry they reference.
63      * @return Number of words consumed from stack by this instruction
64      */
65     public int consumeStack( ConstantPoolGen cpg ) {
66         String JavaDoc signature = getSignature(cpg);
67         Type[] args = Type.getArgumentTypes(signature);
68         int sum;
69         if (opcode == Constants.INVOKESTATIC) {
70             sum = 0;
71         } else {
72             sum = 1; // this reference
73 }
74         int n = args.length;
75         for (int i = 0; i < n; i++) {
76             sum += args[i].getSize();
77         }
78         return sum;
79     }
80
81
82     /**
83      * Also works for instructions whose stack effect depends on the
84      * constant pool entry they reference.
85      * @return Number of words produced onto stack by this instruction
86      */
87     public int produceStack( ConstantPoolGen cpg ) {
88         return getReturnType(cpg).getSize();
89     }
90
91
92     /** @return return type of referenced method.
93      */
94     public Type getType( ConstantPoolGen cpg ) {
95         return getReturnType(cpg);
96     }
97
98
99     /** @return name of referenced method.
100      */
101     public String JavaDoc getMethodName( ConstantPoolGen cpg ) {
102         return getName(cpg);
103     }
104
105
106     /** @return return type of referenced method.
107      */
108     public Type getReturnType( ConstantPoolGen cpg ) {
109         return Type.getReturnType(getSignature(cpg));
110     }
111
112
113     /** @return argument types of referenced method.
114      */
115     public Type[] getArgumentTypes( ConstantPoolGen cpg ) {
116         return Type.getArgumentTypes(getSignature(cpg));
117     }
118 }
119
Popular Tags