    001/*
    002 * Licensed to the Apache Software Foundation (ASF) under one or more
    003 * contributor license agreements.  See the NOTICE file distributed with
    004 * this work for additional information regarding copyright ownership.
    005 * The ASF licenses this file to You under the Apache License, Version 2.0
    006 * (the "License"); you may not use this file except in compliance with
    007 * the License.  You may obtain a copy of the License at
    008 *
    009 *      http://www.apache.org/licenses/LICENSE-2.0
    010 *
    011 *  Unless required by applicable law or agreed to in writing, software
    012 *  distributed under the License is distributed on an "AS IS" BASIS,
    013 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014 *  See the License for the specific language governing permissions and
    015 *  limitations under the License.
    016 *
    017 */
    018package org.apache.bcel.classfile;
    019
    020import java.io.DataInput;
    021import java.io.DataOutputStream;
    022import java.io.IOException;
    023
    024import org.apache.bcel.Const;
    025import org.apache.bcel.Constants;
    026
    027/**
    028 * This class represents a local variable within a method. It contains its
    029 * scope, name, signature and index on the method's frame.
    030 *
    031 * @version $Id: LocalVariable.java 1806728 2017-08-30 19:34:23Z britter $
    032 * @see     LocalVariableTable
    033 */
    034public final class LocalVariable implements Cloneable, Node, Constants {
    035
    036    private int start_pc; // Range in which the variable is valid
    037    private int length;
    038    private int name_index; // Index in constant pool of variable name
    039    private int signature_index; // Index of variable signature
    040    private int index; /* Variable is `index'th local variable on
    041     * this method's frame.
    042     */
    043    private ConstantPool constant_pool;
    044    private int orig_index; // never changes; used to match up with LocalVariableTypeTable entries
    045
    046
    047    /**
    048     * Initialize from another object. Note that both objects use the same
    049     * references (shallow copy). Use copy() for a physical copy.
    050     */
    051    public LocalVariable(final LocalVariable c) {
    052        this(c.getStartPC(), c.getLength(), c.getNameIndex(), c.getSignatureIndex(), c.getIndex(),
    053                c.getConstantPool());
    054        this.orig_index = c.getOrigIndex();
    055    }
    056
    057
    058    /**
    059     * Construct object from file stream.
    060     * @param file Input stream
    061     * @throws IOException
    062     */
    063    LocalVariable(final DataInput file, final ConstantPool constant_pool) throws IOException {
    064        this(file.readUnsignedShort(), file.readUnsignedShort(), file.readUnsignedShort(), file
    065                .readUnsignedShort(), file.readUnsignedShort(), constant_pool);
    066    }
    067
    068
    069    /**
    070     * @param start_pc Range in which the variable
    071     * @param length ... is valid
    072     * @param name_index Index in constant pool of variable name
    073     * @param signature_index Index of variable's signature
    074     * @param index Variable is `index'th local variable on the method's frame
    075     * @param constant_pool Array of constants
    076     */
    077    public LocalVariable(final int start_pc, final int length, final int name_index, final int signature_index, final int index,
    078            final ConstantPool constant_pool) {
    079        this.start_pc = start_pc;
    080        this.length = length;
    081        this.name_index = name_index;
    082        this.signature_index = signature_index;
    083        this.index = index;
    084        this.constant_pool = constant_pool;
    085        this.orig_index = index;
    086    }
    087
    088
    089    /**
    090     * @param start_pc Range in which the variable
    091     * @param length ... is valid
    092     * @param name_index Index in constant pool of variable name
    093     * @param signature_index Index of variable's signature
    094     * @param index Variable is `index'th local variable on the method's frame
    095     * @param constant_pool Array of constants
    096     * @param orig_index Variable is `index'th local variable on the method's frame prior to any changes
    097     */
    098    public LocalVariable(final int start_pc, final int length, final int name_index, final int signature_index, final int index,
    099            final ConstantPool constant_pool, final int orig_index) {
    100        this.start_pc = start_pc;
    101        this.length = length;
    102        this.name_index = name_index;
    103        this.signature_index = signature_index;
    104        this.index = index;
    105        this.constant_pool = constant_pool;
    106        this.orig_index = orig_index;
    107    }
    108
    109
    110    /**
    111     * Called by objects that are traversing the nodes of the tree implicitely
    112     * defined by the contents of a Java class. I.e., the hierarchy of methods,
    113     * fields, attributes, etc. spawns a tree of objects.
    114     *
    115     * @param v Visitor object
    116     */
    117    @Override
    118    public void accept( final Visitor v ) {
    119        v.visitLocalVariable(this);
    120    }
    121
    122
    123    /**
    124     * Dump local variable to file stream in binary format.
    125     *
    126     * @param file Output file stream
    127     * @throws IOException
    128     */
    129    public final void dump( final DataOutputStream file ) throws IOException {
    130        file.writeShort(start_pc);
    131        file.writeShort(length);
    132        file.writeShort(name_index);
    133        file.writeShort(signature_index);
    134        file.writeShort(index);
    135    }
    136
    137
    138    /**
    139     * @return Constant pool used by this object.
    140     */
    141    public final ConstantPool getConstantPool() {
    142        return constant_pool;
    143    }
    144
    145
    146    /**
    147     * @return Variable is valid within getStartPC() .. getStartPC()+getLength()
    148     */
    149    public final int getLength() {
    150        return length;
    151    }
    152
    153
    154    /**
    155     * @return Variable name.
    156     */
    157    public final String getName() {
    158        ConstantUtf8 c;
    159        c = (ConstantUtf8) constant_pool.getConstant(name_index, Const.CONSTANT_Utf8);
    160        return c.getBytes();
    161    }
    162
    163
    164    /**
    165     * @return Index in constant pool of variable name.
    166     */
    167    public final int getNameIndex() {
    168        return name_index;
    169    }
    170
    171
    172    /**
    173     * @return Signature.
    174     */
    175    public final String getSignature() {
    176        ConstantUtf8 c;
    177        c = (ConstantUtf8) constant_pool.getConstant(signature_index, Const.CONSTANT_Utf8);
    178        return c.getBytes();
    179    }
    180
    181
    182    /**
    183     * @return Index in constant pool of variable signature.
    184     */
    185    public final int getSignatureIndex() {
    186        return signature_index;
    187    }
    188
    189
    190    /**
    191     * @return index of register where variable is stored
    192     */
    193    public final int getIndex() {
    194        return index;
    195    }
    196
    197
    198    /**
    199     * @return index of register where variable was originally stored
    200     */
    201    public final int getOrigIndex() {
    202        return orig_index;
    203    }
    204
    205
    206    /**
    207     * @return Start of range where he variable is valid
    208     */
    209    public final int getStartPC() {
    210        return start_pc;
    211    }
    212
    213
    214    /*
    215     * Helper method shared with LocalVariableTypeTable
    216     */
    217    final String toStringShared( final boolean typeTable ) {
    218        final String name = getName();
    219        final String signature = Utility.signatureToString(getSignature(), false);
    220        final String label = "LocalVariable" + (typeTable ? "Types" : "" );
    221        return label + "(start_pc = " + start_pc + ", length = " + length + ", index = "
    222                + index + ":" + signature + " " + name + ")";
    223    }
    224
    225
    226    /**
    227     * @param constant_pool Constant pool to be used for this object.
    228     */
    229    public final void setConstantPool( final ConstantPool constant_pool ) {
    230        this.constant_pool = constant_pool;
    231    }
    232
    233
    234    /**
    235     * @param length the length of this local variable
    236     */
    237    public final void setLength( final int length ) {
    238        this.length = length;
    239    }
    240
    241
    242    /**
    243     * @param name_index the index into the constant pool for the name of this variable
    244     */
    245    public final void setNameIndex( final int name_index ) { // TODO unused
    246        this.name_index = name_index;
    247    }
    248
    249
    250    /**
    251     * @param signature_index the index into the constant pool for the signature of this variable
    252     */
    253    public final void setSignatureIndex( final int signature_index ) { // TODO unused
    254        this.signature_index = signature_index;
    255    }
    256
    257
    258    /**
    259     * @param index the index in the local variable table of this variable
    260     */
    261    public final void setIndex( final int index ) { // TODO unused
    262        this.index = index;
    263    }
    264
    265
    266    /**
    267     * @param start_pc Specify range where the local variable is valid.
    268     */
    269    public final void setStartPC( final int start_pc ) { // TODO unused
    270        this.start_pc = start_pc;
    271    }
    272
    273
    274    /**
    275     * @return string representation.
    276     */
    277    @Override
    278    public final String toString() {
    279        return toStringShared(false);
    280    }
    281
    282
    283    /**
    284     * @return deep copy of this object
    285     */
    286    public LocalVariable copy() {
    287        try {
    288            return (LocalVariable) clone();
    289        } catch (final CloneNotSupportedException e) {
    290            // TODO should this throw?
    291        }
    292        return null;
    293    }
    294}