Source code

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 */
017package org.apache.bcel.classfile;
018
019import java.io.DataInput;
020import java.io.DataInputStream;
021import java.io.DataOutputStream;
022import java.io.IOException;
023import java.util.Arrays;
024
025/**
026 * Abstract super class for fields and methods.
027 */
028public abstract class FieldOrMethod extends AccessFlags implements Cloneable, Node {
029
030    /**
031     * @deprecated (since 6.0) will be made private; do not access directly, use getter/setter
032     */
033    @java.lang.Deprecated
034    protected int name_index; // Points to field name in constant pool
035
036    /**
037     * @deprecated (since 6.0) will be made private; do not access directly, use getter/setter
038     */
039    @java.lang.Deprecated
040    protected int signature_index; // Points to encoded signature
041
042    /**
043     * @deprecated (since 6.0) will be made private; do not access directly, use getter/setter
044     */
045    @java.lang.Deprecated
046    protected Attribute[] attributes; // Collection of attributes
047
048    /**
049     * @deprecated (since 6.0) will be removed (not needed)
050     */
051    @java.lang.Deprecated
052    protected int attributes_count; // No. of attributes
053
054    // @since 6.0
055    private AnnotationEntry[] annotationEntries; // annotations defined on the field or method
056
057    /**
058     * @deprecated (since 6.0) will be made private; do not access directly, use getter/setter
059     */
060    @java.lang.Deprecated
061    protected ConstantPool constant_pool;
062
063    private String signatureAttributeString;
064    private boolean searchedForSignatureAttribute;
065
066    FieldOrMethod() {
067    }
068
069    /**
070     * Constructs object from file stream.
071     *
072     * @param file Input stream
073     * @throws IOException if an I/O error occurs.
074     */
075    protected FieldOrMethod(final DataInput file, final ConstantPool constantPool) throws IOException {
076        this(file.readUnsignedShort(), file.readUnsignedShort(), file.readUnsignedShort(), null, constantPool);
077        final int attributesCount = file.readUnsignedShort();
078        attributes = new Attribute[attributesCount];
079        for (int i = 0; i < attributesCount; i++) {
080            attributes[i] = Attribute.readAttribute(file, constantPool);
081        }
082        this.attributes_count = attributesCount; // init deprecated field
083    }
084
085    /**
086     * Constructs object from file stream.
087     *
088     * @param file Input stream
089     * @throws IOException if an I/O error occurs.
090     * @deprecated (6.0) Use {@link #FieldOrMethod(java.io.DataInput, ConstantPool)} instead.
091     */
092    @java.lang.Deprecated
093    protected FieldOrMethod(final DataInputStream file, final ConstantPool constantPool) throws IOException {
094        this((DataInput) file, constantPool);
095    }
096
097    /**
098     * Initialize from another object. Note that both objects use the same references (shallow copy). Use clone() for a
099     * physical copy.
100     *
101     * @param c Source to copy.
102     */
103    protected FieldOrMethod(final FieldOrMethod c) {
104        this(c.getAccessFlags(), c.getNameIndex(), c.getSignatureIndex(), c.getAttributes(), c.getConstantPool());
105    }
106
107    /**
108     * @param accessFlags Access rights of method
109     * @param nameIndex Points to field name in constant pool
110     * @param signatureIndex Points to encoded signature
111     * @param attributes Collection of attributes
112     * @param constantPool Array of constants
113     */
114    protected FieldOrMethod(final int accessFlags, final int nameIndex, final int signatureIndex, final Attribute[] attributes,
115        final ConstantPool constantPool) {
116        super(accessFlags);
117        this.name_index = nameIndex;
118        this.signature_index = signatureIndex;
119        this.constant_pool = constantPool;
120        setAttributes(attributes);
121    }
122
123    /**
124     * @return deep copy of this field
125     */
126    protected FieldOrMethod copy_(final ConstantPool constantPool) {
127        try {
128            final FieldOrMethod c = (FieldOrMethod) clone();
129            c.constant_pool = constantPool;
130            c.attributes = new Attribute[attributes.length];
131            c.attributes_count = attributes_count; // init deprecated field
132            Arrays.setAll(c.attributes, i -> attributes[i].copy(constantPool));
133            return c;
134        } catch (final CloneNotSupportedException e) {
135            throw new UnsupportedOperationException(e);
136        }
137    }
138
139    /**
140     * Dump object to file stream on binary format.
141     *
142     * @param file Output file stream
143     * @throws IOException if an I/O error occurs.
144     */
145    public final void dump(final DataOutputStream file) throws IOException {
146        file.writeShort(super.getAccessFlags());
147        file.writeShort(name_index);
148        file.writeShort(signature_index);
149        file.writeShort(attributes_count);
150        for (final Attribute attribute : attributes) {
151            attribute.dump(file);
152        }
153    }
154
155    /**
156     * @return Annotations on the field or method
157     * @since 6.0
158     */
159    public AnnotationEntry[] getAnnotationEntries() {
160        if (annotationEntries == null) {
161            annotationEntries = AnnotationEntry.createAnnotationEntries(getAttributes());
162        }
163
164        return annotationEntries;
165    }
166
167    /**
168     * Gets attribute for given tag.
169     * @return Attribute for given tag, null if not found.
170     * Refer to {@link org.apache.bcel.Const#ATTR_UNKNOWN} constants named ATTR_* for possible values.
171     * @since 6.10.0
172     */
173    @SuppressWarnings("unchecked")
174    public final <T extends Attribute> T getAttribute(final byte tag) {
175        for (final Attribute attribute : getAttributes()) {
176            if (attribute.getTag() == tag) {
177                return (T) attribute;
178            }
179        }
180        return null;
181    }
182
183    /**
184     * @return Collection of object attributes.
185     */
186    public final Attribute[] getAttributes() {
187        return attributes;
188    }
189
190    /**
191     * @return Constant pool used by this object.
192     */
193    public final ConstantPool getConstantPool() {
194        return constant_pool;
195    }
196
197    /**
198     * Hunts for a signature attribute on the member and returns its contents. So where the 'regular' signature may be
199     * (Ljava/util/Vector;)V the signature attribute may in fact say 'Ljava/lang/Vector&lt;Ljava/lang/String&gt;;' Coded for
200     * performance - searches for the attribute only when requested - only searches for it once.
201     *
202     * @since 6.0
203     */
204    public final String getGenericSignature() {
205        if (!searchedForSignatureAttribute) {
206            boolean found = false;
207            for (int i = 0; !found && i < attributes.length; i++) {
208                if (attributes[i] instanceof Signature) {
209                    signatureAttributeString = ((Signature) attributes[i]).getSignature();
210                    found = true;
211                }
212            }
213            searchedForSignatureAttribute = true;
214        }
215        return signatureAttributeString;
216    }
217
218    /**
219     * @return Name of object, i.e., method name or field name
220     */
221    public final String getName() {
222        return constant_pool.getConstantUtf8(name_index).getBytes();
223    }
224
225    /**
226     * @return Index in constant pool of object's name.
227     */
228    public final int getNameIndex() {
229        return name_index;
230    }
231
232    /**
233     * @return String representation of object's type signature (Java style)
234     */
235    public final String getSignature() {
236        return constant_pool.getConstantUtf8(signature_index).getBytes();
237    }
238
239    /**
240     * @return Index in constant pool of field signature.
241     */
242    public final int getSignatureIndex() {
243        return signature_index;
244    }
245
246    /**
247     * @param attributes Collection of object attributes.
248     */
249    public final void setAttributes(final Attribute[] attributes) {
250        this.attributes = attributes != null ? attributes : Attribute.EMPTY_ARRAY;
251        this.attributes_count = this.attributes.length; // init deprecated field
252    }
253
254    /**
255     * @param constantPool Constant pool to be used for this object.
256     */
257    public final void setConstantPool(final ConstantPool constantPool) {
258        this.constant_pool = constantPool;
259    }
260
261    /**
262     * @param nameIndex Index in constant pool of object's name.
263     */
264    public final void setNameIndex(final int nameIndex) {
265        this.name_index = nameIndex;
266    }
267
268    /**
269     * @param signatureIndex Index in constant pool of field signature.
270     */
271    public final void setSignatureIndex(final int signatureIndex) {
272        this.signature_index = signatureIndex;
273    }
274}