1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 */ 18 package org.apache.bcel.generic; 19 20 import java.io.DataOutputStream; 21 import java.io.IOException; 22 23 import org.apache.bcel.classfile.Constant; 24 import org.apache.bcel.classfile.ConstantClass; 25 import org.apache.bcel.classfile.ConstantPool; 26 import org.apache.bcel.util.ByteSequence; 27 28 /** 29 * Abstract super class for instructions that use an index into the 30 * constant pool such as LDC, INVOKEVIRTUAL, etc. 31 * 32 * @see ConstantPoolGen 33 * @see LDC 34 * @see INVOKEVIRTUAL 35 * 36 * @version $Id$ 37 */ 38 public abstract class CPInstruction extends Instruction implements TypedInstruction, 39 IndexedInstruction { 40 41 /** 42 * @deprecated (since 6.0) will be made private; do not access directly, use getter/setter 43 */ 44 @Deprecated 45 protected int index; // index to constant pool 46 47 48 /** 49 * Empty constructor needed for Instruction.readInstruction. 50 * Not to be used otherwise. 51 */ CPInstruction()52 CPInstruction() { 53 } 54 55 56 /** 57 * @param index to constant pool 58 */ CPInstruction(final short opcode, final int index)59 protected CPInstruction(final short opcode, final int index) { 60 super(opcode, (short) 3); 61 setIndex(index); 62 } 63 64 65 /** 66 * Dump instruction as byte code to stream out. 67 * @param out Output stream 68 */ 69 @Override dump( final DataOutputStream out )70 public void dump( final DataOutputStream out ) throws IOException { 71 out.writeByte(super.getOpcode()); 72 out.writeShort(index); 73 } 74 75 76 /** 77 * Long output format: 78 * 79 * <name of opcode> "["<opcode number>"]" 80 * "("<length of instruction>")" "<"< constant pool index>">" 81 * 82 * @param verbose long/short format switch 83 * @return mnemonic for instruction 84 */ 85 @Override toString( final boolean verbose )86 public String toString( final boolean verbose ) { 87 return super.toString(verbose) + " " + index; 88 } 89 90 91 /** 92 * @return mnemonic for instruction with symbolic references resolved 93 */ 94 @Override toString( final ConstantPool cp )95 public String toString( final ConstantPool cp ) { 96 final Constant c = cp.getConstant(index); 97 String str = cp.constantToString(c); 98 if (c instanceof ConstantClass) { 99 str = str.replace('.', '/'); 100 } 101 return org.apache.bcel.Const.getOpcodeName(super.getOpcode()) + " " + str; 102 } 103 104 105 /** 106 * Read needed data (i.e., index) from file. 107 * @param bytes input stream 108 * @param wide wide prefix? 109 */ 110 @Override initFromFile( final ByteSequence bytes, final boolean wide )111 protected void initFromFile( final ByteSequence bytes, final boolean wide ) throws IOException { 112 setIndex(bytes.readUnsignedShort()); 113 super.setLength(3); 114 } 115 116 117 /** 118 * @return index in constant pool referred by this instruction. 119 */ 120 @Override getIndex()121 public final int getIndex() { 122 return index; 123 } 124 125 126 /** 127 * Set the index to constant pool. 128 * @param index in constant pool. 129 */ 130 @Override setIndex( final int index )131 public void setIndex( final int index ) { // TODO could be package-protected? 132 if (index < 0) { 133 throw new ClassGenException("Negative index value: " + index); 134 } 135 this.index = index; 136 } 137 138 139 /** @return type related with this instruction. 140 */ 141 @Override getType( final ConstantPoolGen cpg )142 public Type getType( final ConstantPoolGen cpg ) { 143 final ConstantPool cp = cpg.getConstantPool(); 144 String name = cp.getConstantString(index, org.apache.bcel.Const.CONSTANT_Class); 145 if (!name.startsWith("[")) { 146 name = "L" + name + ";"; 147 } 148 return Type.getType(name); 149 } 150 } 151