/*
 * reserved comment block
 * DO NOT REMOVE OR ALTER!
 */
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.sun.org.apache.bcel.internal.generic;

import java.util.StringTokenizer;

import com.sun.org.apache.bcel.internal.Const;
import com.sun.org.apache.bcel.internal.classfile.Constant;
import com.sun.org.apache.bcel.internal.classfile.ConstantCP;
import com.sun.org.apache.bcel.internal.classfile.ConstantPool;

Super class for the INVOKExxx family of instructions.
Version:$Id: InvokeInstruction.java 1752106 2016-07-10 20:02:39Z britter $
/** * Super class for the INVOKExxx family of instructions. * * @version $Id: InvokeInstruction.java 1752106 2016-07-10 20:02:39Z britter $ */
public abstract class InvokeInstruction extends FieldOrMethod implements ExceptionThrower, StackConsumer, StackProducer {
Empty constructor needed for the Class.newInstance() statement in Instruction.readInstruction(). Not to be used otherwise.
/** * Empty constructor needed for the Class.newInstance() statement in * Instruction.readInstruction(). Not to be used otherwise. */
InvokeInstruction() { }
Params:
  • index – to constant pool
/** * @param index to constant pool */
protected InvokeInstruction(final short opcode, final int index) { super(opcode, index); }
Returns:mnemonic for instruction with symbolic references resolved
/** * @return mnemonic for instruction with symbolic references resolved */
@Override public String toString( final ConstantPool cp ) { final Constant c = cp.getConstant(super.getIndex()); final StringTokenizer tok = new StringTokenizer(cp.constantToString(c)); return Const.getOpcodeName(super.getOpcode()) + " " + tok.nextToken().replace('.', '/') + tok.nextToken(); }
Also works for instructions whose stack effect depends on the constant pool entry they reference.
Returns:Number of words consumed from stack by this instruction
/** * Also works for instructions whose stack effect depends on the * constant pool entry they reference. * @return Number of words consumed from stack by this instruction */
@Override public int consumeStack( final ConstantPoolGen cpg ) { int sum; if ((super.getOpcode() == Const.INVOKESTATIC) || (super.getOpcode() == Const.INVOKEDYNAMIC)) { sum = 0; } else { sum = 1; // this reference } final String signature = getSignature(cpg); sum += Type.getArgumentTypesSize(signature); return sum; }
Also works for instructions whose stack effect depends on the constant pool entry they reference.
Returns:Number of words produced onto stack by this instruction
/** * Also works for instructions whose stack effect depends on the * constant pool entry they reference. * @return Number of words produced onto stack by this instruction */
@Override public int produceStack( final ConstantPoolGen cpg ) { final String signature = getSignature(cpg); return Type.getReturnTypeSize(signature); }
This overrides the deprecated version as we know here that the referenced class may legally be an array.
Throws:
Deprecated:in FieldOrMethod
Returns:name of the referenced class/interface
/** * This overrides the deprecated version as we know here that the referenced class * may legally be an array. * * @deprecated in FieldOrMethod * * @return name of the referenced class/interface * @throws IllegalArgumentException if the referenced class is an array (this should not happen) */
@Override @Deprecated public String getClassName( final ConstantPoolGen cpg ) { final ConstantPool cp = cpg.getConstantPool(); final ConstantCP cmr = (ConstantCP) cp.getConstant(super.getIndex()); final String className = cp.getConstantString(cmr.getClassIndex(), Const.CONSTANT_Class); return className.replace('/', '.'); }
Returns:return type of referenced method.
/** @return return type of referenced method. */
@Override public Type getType( final ConstantPoolGen cpg ) { return getReturnType(cpg); }
Returns:name of referenced method.
/** @return name of referenced method. */
public String getMethodName( final ConstantPoolGen cpg ) { return getName(cpg); }
Returns:return type of referenced method.
/** @return return type of referenced method. */
public Type getReturnType( final ConstantPoolGen cpg ) { return Type.getReturnType(getSignature(cpg)); }
Returns:argument types of referenced method.
/** @return argument types of referenced method. */
public Type[] getArgumentTypes( final ConstantPoolGen cpg ) { return Type.getArgumentTypes(getSignature(cpg)); } }