    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.IOException;
    021import java.util.Objects;
    022
    023import org.apache.bcel.generic.Type;
    024import org.apache.bcel.util.BCELComparator;
    025
    026/**
    027 * This class represents the method info structure, i.e., the representation for a method in the class. See JVM
    028 * specification for details. A method has access flags, a name, a signature and a number of attributes.
    029 */
    030public final class Method extends FieldOrMethod {
    031
    032    /**
    033     * Empty array constant.
    034     *
    035     * @since 6.6.0
    036     */
    037    public static final Method[] EMPTY_ARRAY = {};
    038
    039    private static BCELComparator<Method> bcelComparator = new BCELComparator<Method>() {
    040
    041        @Override
    042        public boolean equals(final Method a, final Method b) {
    043            return a == b || a != null && b != null && Objects.equals(a.getName(), b.getName()) && Objects.equals(a.getSignature(), b.getSignature());
    044        }
    045
    046        @Override
    047        public int hashCode(final Method o) {
    048            return o != null ? Objects.hash(o.getSignature(), o.getName()) : 0;
    049        }
    050    };
    051
    052    /**
    053     * @return Comparison strategy object.
    054     */
    055    public static BCELComparator<Method> getComparator() {
    056        return bcelComparator;
    057    }
    058
    059    /**
    060     * @param comparator Comparison strategy object.
    061     */
    062    public static void setComparator(final BCELComparator<Method> comparator) {
    063        bcelComparator = comparator;
    064    }
    065
    066    /** Annotations defined on the parameters of a method. */
    067    private ParameterAnnotationEntry[] parameterAnnotationEntries;
    068
    069    /**
    070     * Empty constructor, all attributes have to be defined via 'setXXX' methods. Use at your own risk.
    071     */
    072    public Method() {
    073    }
    074
    075    /**
    076     * Constructs object from file stream.
    077     *
    078     * @param file Input stream
    079     * @throws IOException if an I/O error occurs.
    080     * @throws ClassFormatException if a class is malformed or cannot be interpreted as a class file
    081     */
    082    Method(final DataInput file, final ConstantPool constantPool) throws IOException, ClassFormatException {
    083        super(file, constantPool);
    084    }
    085
    086    /**
    087     * @param accessFlags Access rights of method
    088     * @param nameIndex Points to field name in constant pool
    089     * @param signatureIndex Points to encoded signature
    090     * @param attributes Collection of attributes
    091     * @param constantPool Array of constants
    092     */
    093    public Method(final int accessFlags, final int nameIndex, final int signatureIndex, final Attribute[] attributes, final ConstantPool constantPool) {
    094        super(accessFlags, nameIndex, signatureIndex, attributes, 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    public Method(final Method c) {
    104        super(c);
    105    }
    106
    107    /**
    108     * Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
    109     * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
    110     *
    111     * @param v Visitor object
    112     */
    113    @Override
    114    public void accept(final Visitor v) {
    115        v.visitMethod(this);
    116    }
    117
    118    /**
    119     * @return deep copy of this method
    120     */
    121    public Method copy(final ConstantPool constantPool) {
    122        return (Method) copy_(constantPool);
    123    }
    124
    125    /**
    126     * Return value as defined by given BCELComparator strategy. By default two method objects are said to be equal when
    127     * their names and signatures are equal.
    128     *
    129     * @see Object#equals(Object)
    130     */
    131    @Override
    132    public boolean equals(final Object obj) {
    133        return obj instanceof Method && bcelComparator.equals(this, (Method) obj);
    134    }
    135
    136    /**
    137     * @return array of method argument types
    138     */
    139    public Type[] getArgumentTypes() {
    140        return Type.getArgumentTypes(getSignature());
    141    }
    142
    143    /**
    144     * @return Code attribute of method, if any
    145     */
    146    public Code getCode() {
    147        for (final Attribute attribute : super.getAttributes()) {
    148            if (attribute instanceof Code) {
    149                return (Code) attribute;
    150            }
    151        }
    152        return null;
    153    }
    154
    155    /**
    156     * @return ExceptionTable attribute of method, if any, i.e., list all exceptions the method may throw not exception
    157     *         handlers!
    158     */
    159    public ExceptionTable getExceptionTable() {
    160        for (final Attribute attribute : super.getAttributes()) {
    161            if (attribute instanceof ExceptionTable) {
    162                return (ExceptionTable) attribute;
    163            }
    164        }
    165        return null;
    166    }
    167
    168    /**
    169     * @return LineNumberTable of code attribute if any, i.e. the call is forwarded to the Code atribute.
    170     */
    171    public LineNumberTable getLineNumberTable() {
    172        final Code code = getCode();
    173        if (code == null) {
    174            return null;
    175        }
    176        return code.getLineNumberTable();
    177    }
    178
    179    /**
    180     * @return LocalVariableTable of code attribute if any, i.e. the call is forwarded to the Code atribute.
    181     */
    182    public LocalVariableTable getLocalVariableTable() {
    183        final Code code = getCode();
    184        if (code == null) {
    185            return null;
    186        }
    187        return code.getLocalVariableTable();
    188    }
    189
    190    /**
    191     * @return Annotations on the parameters of a method
    192     * @since 6.0
    193     */
    194    public ParameterAnnotationEntry[] getParameterAnnotationEntries() {
    195        if (parameterAnnotationEntries == null) {
    196            parameterAnnotationEntries = ParameterAnnotationEntry.createParameterAnnotationEntries(getAttributes());
    197        }
    198        return parameterAnnotationEntries;
    199    }
    200
    201    /**
    202     * @return return type of method
    203     */
    204    public Type getReturnType() {
    205        return Type.getReturnType(getSignature());
    206    }
    207
    208    /**
    209     * Return value as defined by given BCELComparator strategy. By default return the hash code of the method's name XOR
    210     * signature.
    211     *
    212     * @see Object#hashCode()
    213     */
    214    @Override
    215    public int hashCode() {
    216        return bcelComparator.hashCode(this);
    217    }
    218
    219    /**
    220     * Return string representation close to declaration format, 'public static void main(String[] args) throws
    221     * IOException', e.g.
    222     *
    223     * @return String representation of the method.
    224     */
    225    @Override
    226    public String toString() {
    227        final String access = Utility.accessToString(super.getAccessFlags());
    228        // Get name and signature from constant pool
    229        ConstantUtf8 c = super.getConstantPool().getConstantUtf8(super.getSignatureIndex());
    230        String signature = c.getBytes();
    231        c = super.getConstantPool().getConstantUtf8(super.getNameIndex());
    232        final String name = c.getBytes();
    233        signature = Utility.methodSignatureToString(signature, name, access, true, getLocalVariableTable());
    234        final StringBuilder buf = new StringBuilder(signature);
    235        for (final Attribute attribute : super.getAttributes()) {
    236            if (!(attribute instanceof Code || attribute instanceof ExceptionTable)) {
    237                buf.append(" [").append(attribute).append("]");
    238            }
    239        }
    240        final ExceptionTable e = getExceptionTable();
    241        if (e != null) {
    242            final String str = e.toString();
    243            if (!str.isEmpty()) {
    244                buf.append("\n\t\tthrows ").append(str);
    245            }
    246        }
    247        return buf.toString();
    248    }
    249}