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 if (attributes != null) { 151 for (final Attribute attribute : attributes) { 152 attribute.dump(file); 153 } 154 } 155 } 156 157 /** 158 * @return Annotations on the field or method 159 * @since 6.0 160 */ 161 public AnnotationEntry[] getAnnotationEntries() { 162 if (annotationEntries == null) { 163 annotationEntries = AnnotationEntry.createAnnotationEntries(getAttributes()); 164 } 165 166 return annotationEntries; 167 } 168 169 /** 170 * @return Collection of object attributes. 171 */ 172 public final Attribute[] getAttributes() { 173 return attributes; 174 } 175 176 /** 177 * @return Constant pool used by this object. 178 */ 179 public final ConstantPool getConstantPool() { 180 return constant_pool; 181 } 182 183 /** 184 * Hunts for a signature attribute on the member and returns its contents. So where the 'regular' signature may be 185 * (Ljava/util/Vector;)V the signature attribute may in fact say 'Ljava/lang/Vector<Ljava/lang/String>;' Coded for 186 * performance - searches for the attribute only when requested - only searches for it once. 187 * 188 * @since 6.0 189 */ 190 public final String getGenericSignature() { 191 if (!searchedForSignatureAttribute) { 192 boolean found = false; 193 for (int i = 0; !found && i < attributes.length; i++) { 194 if (attributes[i] instanceof Signature) { 195 signatureAttributeString = ((Signature) attributes[i]).getSignature(); 196 found = true; 197 } 198 } 199 searchedForSignatureAttribute = true; 200 } 201 return signatureAttributeString; 202 } 203 204 /** 205 * @return Name of object, i.e., method name or field name 206 */ 207 public final String getName() { 208 return constant_pool.getConstantUtf8(name_index).getBytes(); 209 } 210 211 /** 212 * @return Index in constant pool of object's name. 213 */ 214 public final int getNameIndex() { 215 return name_index; 216 } 217 218 /** 219 * @return String representation of object's type signature (Java style) 220 */ 221 public final String getSignature() { 222 return constant_pool.getConstantUtf8(signature_index).getBytes(); 223 } 224 225 /** 226 * @return Index in constant pool of field signature. 227 */ 228 public final int getSignatureIndex() { 229 return signature_index; 230 } 231 232 /** 233 * @param attributes Collection of object attributes. 234 */ 235 public final void setAttributes(final Attribute[] attributes) { 236 this.attributes = attributes; 237 this.attributes_count = attributes != null ? attributes.length : 0; // init deprecated field 238 } 239 240 /** 241 * @param constantPool Constant pool to be used for this object. 242 */ 243 public final void setConstantPool(final ConstantPool constantPool) { 244 this.constant_pool = constantPool; 245 } 246 247 /** 248 * @param nameIndex Index in constant pool of object's name. 249 */ 250 public final void setNameIndex(final int nameIndex) { 251 this.name_index = nameIndex; 252 } 253 254 /** 255 * @param signatureIndex Index in constant pool of field signature. 256 */ 257 public final void setSignatureIndex(final int signatureIndex) { 258 this.signature_index = signatureIndex; 259 } 260}